Un menù dinamico per app mobile (con Delphi XE5 per iOS e Android)

Introduzione

Uno dei problemi più comuni quando si sviluppa un'applicazione mobile è che, per implementare tutte le funzionalità richieste, abbiamo bisogno di più "schermate" (per esempio perchè dobbiamo visualizzare molti dati o controlli utente o perchè le funzionalità richiedono di essere suddivise in unità visuali isolate).

Al di là della scelta da compiere (valutando i pro e contro del caso) fra l'uso di TTabControl con più pagine rispetto all'opzione di realizzare una applicazione con più form, per tutti esiste il problema di guidare il proprio utente attraverso le varie "schermate".

Una soluzione molto diffusa è quella di implementare un drawer (un compartimento laterale a scomparsa che mostra un elenco di voci cliccabili). José Leon ha una serie di articoli a riguardo che sono molto interessanti.

Alternativamente, è possibile avere un pulsante che mostri un pannello a scomparsa più piccolo (simile ad un popup menu) e trovate un esempio di questo sempre sul blog di José Leon. 

Voglio proporvi anche un'altra alternativa, con relativa implementazione di base, che consiste in un menù (sempre a scomparsa: lo spazio è prezioso nelle app mobile) ma che abbia un po' di flessibilità sul numero di elementi cliccabili e che sia facile da manutenere a design-time.

Realizzazione

In breve, ho cercato di combinare la flessibilità (e le performance) di una TListView con il meccanismo di transizione a scomparsa utilizzato anche negli altri approcci che vi ho indicato poco sopra. Inoltre, per cercare di rendere più facile l'utilizzo e la manutenzione del menù a design-time, ho pensato di usufruire di una TActionList (comoda da maneggiare nell'IDE): lo sviluppatore in questo modo non deve fare altro che popolare l'ActionList con le voci che vorrà ritrovare nel menù a scomparsa.

Come potete vedere dal seguente screenshot, i componenti del MenuLayout (che rappresenta il menù nella sua interezza), sono sostanzialmente una TListView, un paio di animazioni, un MenuButton (in realtà un'istanza di TRectangle, colorato con un gradiente) che permette all'utente di avere un punto di "presa" del menù anche quando è chiuso e un effetto di ombra usato fini estetici.

A design-time, lo sviluppatore vede il menù "chiuso", nella parte superiore della form, riducendo così anche fastidiosi "ingombri" durante la fase di sviluppo del resto dell'applicazione:

Nota: il triangolo che si vede è realizzato usando un pezzetto di SVG e un componente TPath (questa funzionalità di FireMonkey mi piace molto e probabilmente sarà oggetto di un futuro blog post).

Grazie ad un utilizzo mirato delle proprietà Align, la MenuListView ha modo di crescere (in verticale) insieme al MenuLayout, mentre il MenuButton è allineato alBottom (in modo da essere sempre sul fondo inferiore del MenuLayout.

L'esecuzione (una tantum) di un pezzo di codice che aggiunge dinamicamente (a runtime) gli item alla TListView partendo dal contenuto della MenuActionList, ci porta in una situazione in cui per ogni action esiste un elemento della TListView. 

Dato che vogliamo preservare la piena funzionalità sia che si tratti di pochi elementi o di molti, sfruttiamo le funzionalità di scroll insite nella TListView per ottenere (senza sforzo) che, qualora gli elementi dovessero essere più di quelli che si possono mostrare fisicamente nello spazio disponibile, l'utente abbia facoltà di vederne solo alcuni ma poter fare scroll della ListView (come di consueto).

Due istanze di TFloatAnimation (MenuDownAnimation e MenuUpAnimation) sono state impostate per espandere il MenuLayout (agendo sulla sua proprietà Height) tanto quanto necessario per mostrare gli elementi del menù (con un effetto grafico piacevole e che potete ulteriormente customizzare modificando le opzioni delle animation stesse) e, viceversa, per collassarlo nuovamente. 

Questo è tutto ciò che ci serve dal punto di vista dei componenti visuali; per quanto riguarda il codice, vi riporto di seguito la porzione che si occupa di travasare le action in elementi della TListView:

procedure TMainForm.BuildMenuItems;
var
  LAction: TAction;
  LIndex: Integer;
  LItem: TListViewItem;
begin
  MenuListView.ItemAppearance.ItemHeight := 75;
  for LIndex := 0 to MenuActionList.ActionCount -1 do
  begin
    LAction := MenuActionList.Actions[LIndex] as TAction;

    LItem := MenuListView.Items.Add;
    try
      LItem.Text := LAction.Text;
      ItemActionDict.Add(LItem, LAction);
    except
      LItem.Free;
      raise;
    end;
  end;
end;

Come potete vedere è tutto abbastanza semplice e si nota l'utilizzo di ItemActionDict: una istanza di TDictionary<TListViewItem, TAction> che mi permette di realizzare una lista associativa fra gli elementi della TListView e le Action della TActionList.
Questa associazione servirà quando, nella gestione dell'evento di click dell'item della TListView, occorre sapere quale action eseguire:

procedure TMainForm.MenuListViewItemClick(const Sender: TObject;
  const AItem: TListViewItem);
var
  LItem: TListViewItem;
  LAction: TAction;
begin
  if ItemActionDict.TryGetValue(AItem, LAction) then
  begin
    if LAction.Execute then
      MenuUp;
  end;
end;

Il resto del codice è molto semplice e lo trovate nei sorgenti completi dell'applicazione di esempio che ho realizzato e di cui vedete alcuni screenshot di seguito (presi con un Nexus 7 e con un iPad):

 

 

Per ottenere un effetto di differenziazione rispetto al normale contenuto della form, ho personalizzato la MenuListView implementando un gestore per l'evento OnUpdatingObjects, che mi fornisce l'occasione di cambiare il colore del testo di ogni item della TListView;

procedure TMainForm.MenuListViewUpdatingObjects(const Sender: TObject;
  const AItem: TListViewItem; var AHandled: Boolean);
begin
  if Assigned(AItem) and Assigned(AItem.Objects) and Assigned(AItem.Objects.TextObject)
     and (AItem.Index < High(FItemColors))
  then
    AItem.Objects.TextObject.TextColor := FItemColors[AItem.Index];
end;

Inoltre, ho voluto personalizzare il colore di sfondo degli item della TListView, per averlo più scuro (differenziando quindi questa TListView dalle altre presenti nell'applicazione), implementando il metodo OnApplyStyleLookup e sfruttando un piccolo hack: modifico dinamicamente un valore dettato dallo style della TListView, in particolare il TColorObject di nome 'itembackground':

procedure TMainForm.MenuListViewApplyStyleLookup(Sender: TObject);
var
  LStyleObject: TFmxObject;
begin
  // hack the ListView style to have a dark background
  LStyleObject := MenuListView.FindStyleResource('itembackground');
  if LStyleObject is TColorObject then
    TColorObject(LStyleObject).Color := TAlphaColorRec.Slategray;
end;

Vi invito a provare ad aggiungere altre Action alla MenuActionList, tante da ottenere l'effetto di scroll nella TListView: il risultato è molto carino!

Conclusioni e materiale

Abbiamo visto come FireMonkey ci offra la possibilità di ottenere con facilità degli effetti grafici (animati) gradevoli e al contempo implementare una funzionalità fondamentale come può essere quella di un menù (con un numero arbitrario di voci) a scomparsa per una applicazione mobile.

Vi lascio anche qualche spunto per sviluppi ulteriori (più o meno facili, in ordine sparso):

• espandere un po' gli effetti e le animazioni del menù, per migliorarne l'estetica e la user experience;
• gestire lo stato di abilitazione/visibilità delle action corrispondenti gli item del menù;
• aggiungere un supporto a icone da abbinare alle voci di menù;
• migliorare la personalizzazione dei colori delle voci di menù;
• rimuovere il MenuButton e al suo posto sfruttare delle gestures (o su Android, il pulsante Settings).

Vi lascio come di consueto i link al codice sorgente completo dell'applicazione demo realizzata e ad un'applicazione demo compilata per Android (APK).

Link: Codice sorgente Delphi XE5
Link: Demo APK (da installare sul vostro dispositivo Android)

Buon lavoro e a presto!

Andrea

Leggere e produrre Barcode con Delphi XE5 (Android)

UPDATE: Nuovo blog post con la versione XE7

Introduzione

Esistono online diversi articoli che parlano di come integrare la lettura di codici a barre in applicazioni mobile Delphi (trovate dei link anche nel seguito di questo post).

Vedremo ora un approccio che permette di aggiungere le funzionalità di scansione e produzione di codici a barre (e/o QR code) in una app Delphi (Android), senza necessità di installare componenti di terze parti o compilare nella vostra app librerie di terzi.

Tutto si basa sull'interazione, mediata dal sistema operativo, con una applicazione già esistente (molto diffusa, gratuita e disponibile su Google Play Store) che si chiama Barcode Scanner (dettagli sulla licenza qui).

A costo di un certo livello di dipendenza da questa applicazione di terzi, il beneficio è di poterla sfruttare al massimo con poco sforzo, realizzando facilmente funzionalità che potrebbero essere sufficienti in un buon numero di situazioni.

Pro e contro

Vi anticipo subito quali sono i pregi/difetti di questo approccio:

Contro

1. Si genera una dipendenza con Barcode Scanner (anche se solo per quanto riguarda le funzionalità di lettura/produzione di barcode, non per l'esecuzione in sè della vostra app): i vostri utenti dovranno installare sui loro dispositivi anche questa applicazione (attualmente gratuita);
2. La funzionalità di lettura (scan) dei barcode si basa sull'assunto che Barcode Scanner di chiuda dopo aver scansionato un codice e copi il codice letto nella clipboard del dispositivo; se future versioni dell'applicazione dovessero comportarsi diversamente, la vostra applicazione potrebbe non funzionare;
3. questa soluzione non è crossplatform (è valida solo per Android)

Pro

1. Tutta la complessità di implementazione viene delegata a Barcode Scanner (incluso il supporto a numerosi formati di codici a barre e la gestione della camera);
2.  Non è necessaria alcuna libreria di terze parti da compilare con la vostra applicazione;
3. Sia la lettura che la produzione di codici a barre si risolve con una manciata di righe di codice!

Altri approcci e link di riferimento

• Articolo di Fernando Rizzatto (iOS, ZBar SDK)
• Video di Jim McKeeth (iOS + Android)
• Articolo di Pawel Glowacki sulla gestione degli eventi delle applicazioni

Intent

Un Intent è sostanzialmente una descrizione di una operazione da compiere. Le applicazioni Android (activity) possono interagire attraverso gli intent (chiamandoli e registrandosi per servirli) un po' come le applicazioni Win32/64 possono interagire tramite ShellExecute o CreateProcess.

In Delphi sono presenti delle unit che ci aiutano a maneggiare direttamente i wrapper delle classi Java interessate e che ci permettono di effettuare le necessarie conversioni di tipo fra i tipi di dato Delphi e quelli Java. In particolare sono tre le unit che ci serviranno:

1. Androidapi.JNI.GraphicsContentViewText, dove è definito il wrapper JIntent;
2. Androidapi.JNI.JavaTypes, dove troviamo SharedActivity (una JActivity);
3. FMX.Helpers.Android, che offre funzioni di utilità come StringToJString.

Una volta incluse queste unit, siamo in condizione di dichiarare ed eseguire un intent.

Come potete vedere in questo file Java di Barcode Scanner, essa espone diversi intent fra cui uno per avviare una scansione di un codice a barre e uno per produrre un codice a barre partendo da un contenuto testuale fornito nei parametri dell'intent.

Primo step: produzione di un codice a barre

Con queste poche righe di codice possiamo preparare ed eseguire l'intent ENCODE di Barcode Scanner:

procedure TForm1.ButtonProduceClick(Sender: TObject);
var
  Intent: JIntent;
begin
  Intent := TJIntent.JavaClass.init(StringToJString('com.google.zxing.client.android.ENCODE'));
  Intent.setPackage(StringToJString('com.google.zxing.client.android'));

  Intent.putExtra(StringToJString('ENCODE_TYPE'), StringToJString('TEXT_TYPE'));
  Intent.putExtra(StringToJString('ENCODE_FORMAT'), StringToJString(ComboBoxFormat.Items[ComboboxFormat.ItemIndex]));
  Intent.putExtra(StringToJString('ENCODE_DATA'), StringToJString(Memo1.Lines.Text));

  SharedActivityContext.startActivity(Intent);
end;

• Il valore ENCODE_DATA rappresenta il contenuto che vogliamo rendere con il barcode (ed è il contenuto di un memo presente sulla form della nostra applicazione);
• ENCODE_FORMAT rappresenta il tipo di codice a barre che vogliamo produrre (nel nostro esempio è preso da un combobox sulla form). I formati supportati attualmente sono i seguenti:
  "UPC_A", "UPC_E", "EAN_8", "EAN_13", "CODE_39", "CODE_93", "CODE_128", "ITF", "RSS_14", "RSS_EXPANDED", "QR_CODE", "DATA_MATRIX".

Il risultato è che una volta lanciata l'activity descritta dal nostro intent, l'applicazione Barcode Scanner verrà eseguita e riceverà i parametri che abbiamo impostato nell'intent, producendo per noi un barcode del tipo specificato e con il contenuto indicato.

Secondo step: lettura di un codice a barre

Sfruttando un secondo intent disponibile, possiamo chiedere a Barcode Scanner di avviarsi in modalità SCAN, presentando all'utente la tipica interfaccia grafica per individuare con la camera un codice a barre e scansionarlo. Una volta acquisito il codice, l'applicazione emette un beep acustico e si chiude, dopo aver copiato negli appunti il valore scansionato. Questo fa sì che la nostra applicazione torni in primo piano.

Il codice per eseguire l'intent SCAN è il seguente:

var
  Intent: JIntent;
begin
  // empty the clipboard (to be sure not to match previous results)
  FClipBoardService.SetClipboard('');
  WaitingForResults := True;

  // launch Barcode Scanner in SCAN mode
  Intent := TJIntent.JavaClass.init(StringToJString('com.google.zxing.client.android.SCAN'));
  Intent.setPackage(StringToJString('com.google.zxing.client.android'));

  Intent.putExtra(StringToJString('SCAN_MODE'), StringToJString('ONE_D_MODE,QR_CODE_MODE,PRODUCT_MODE,DATA_MATRIX_MODE'));

  SharedActivityContext.startActivity(Intent);
end;

In teoria, il modo corretto di intercettare la fine dell'attività di scansione sarebbe implementare un gestore per onActivityResult ma questo comporta attualmente alcune complicazioni tecniche.
Usiamo quindi un semplice workaround: intercettiamo l'evento che ci segnala che la nostra applicazione è di nuovo in primo piano (ottimo articolo di Pawel Glowacki) e leggiamo il contenuto degli appunti per catturare il testo corrispondente al barcode letto da Barcode Scanner.

Codice per agganciare gli eventi dell'applicazione e per ottenere un riferimento alla clipboard:

procedure TForm1.FormCreate(Sender: TObject);
begin
  FWaitingForResults := False;

  if not TPlatformServices.Current.SupportsPlatformService(IFMXClipboardService, IInterface(FClipBoardService)) then
    raise Exception.Create('Cannot get access to clipboard service!');

  if not TPlatformServices.Current.SupportsPlatformService(IFMXApplicationEventService, IInterface(FApplicationEventService)) then
    raise Exception.Create('Cannot get application event service');
  FApplicationEventService.SetApplicationEventHandler(ApplicationEventHandler);
end;

Codice per l'event-handler dei cambi di stato dell'applicazione:

function TForm1.ApplicationEventHandler(AAppEvent: TApplicationEvent;
  AContext: TObject): Boolean;
var
  LClipboardContent: string;
  LFound: Boolean;
begin
  case AAppEvent of
    aeBecameActive:
      begin
        if WaitingForResults then
        begin
          WaitingForResults := False;
          LClipboardContent := FClipBoardService.GetClipboard.AsString;
          LFound := LClipboardContent <> '';

          if LFound then
            Log('Scan successful: ' + LClipboardContent)
          else
            Log('Scan failed (please retry)');
        end;
      end;
  end;
  Result := True;
end;

La procedura Log non fa altro che scrivere nel Memo della form principale.

Conclusioni e materiale

Questo è tutto. Come vedete si tratta di poche righe di codice e il meccanismo è semplice ma efficace.
Se le vostre esigenze di leggere e produrre barcode non sono particolarmente eccessive, un approccio come quello illustrato dovrebbe essere una soluzione sufficiente nella maggioranza dei casi.

Link: Codice sorgente Delphi XE5
Link: Demo APK (da installare sul vostro dispositivo Android)

UPDATE: Nuovo blog post con la versione XE7

Buon lavoro e a presto!
Andrea

90 giorni al Delphi Day 2014 (save the date!)

Mancano (meno di) novanta giorni al Delphi Day 2014, l'evento annuale che rappresenta il punto di incontro degli sviluppatori Delphi in Italia!

Giunto alla sua tredicesima edizione, è organizzato da Wintech-Italia e si terrà (come di consueto) a Piacenza il giorno 11 giugno 2014. Non potete mancare! :-)

Link: Qualche fotografia dall'edizione 2013

La roadmap di Delphi ed il nuovo Appmethod

Tempo di novità in Embarcadero: dopo aver annunciato la nuova roadmap di Delphi per il 2014 e oltre, un po' a sorpresa è arrivato l'annuncio di un nuovo prodotto, Appmethod.
Appmethod è un tool dedicato agli sviluppatori per generare applicazioni multi-piattaforma: Windows, Mac OS X, iOS, Android. Vi ricorda qualcosa? :-)

Vediamo nel dettaglio queste due novità.

Delphi (e C++ Builder) Roadmap

La nuova roadmap di Delphi pubblicata in marzo 2014 comincia con il consueto disclaimer:

Le funzionalità presentate nella roadmap non sono da considerare vincolanti per Embarcadero da sviluppare o inserire nel prodotto, il momento in cui appariranno nel prodotto può essere diverso da quanto riportato nella roadmap. Infine, Embarcadero si riserva il diritto di cambiare la roadmap in qualsiasi momento.

Funzionalità e tecnologie inserite nel prodotto nel 2013

Nel 2013 l'obbiettivo primario del team di RAD Studio è stato quello di inserire i processori ARM (e i sistemi operativi iOS e Android) come target per i compilatori e le librerie di supporto. In questo momento Delphi supporta sia iOS sia Android mentre C++ Builder solo iOS (Update 2). Le librerie includono FireMonkey (FMX), la libreria RTL, i componenti per l'accesso ai database (FireDAC), ecco l'elenco:

• Supporto Delphi e C++ per iOS su processore ARM (compiler, linker, debugger)
• Supporto Delphi per Android su processore ARM (compiler, linker, debugger)
• Framework FMX per Android e iOS, incluse: RTL, database library e supporto per l'interazione con le API dei sensori mobile
• Embedded InterBase per le piattaforme mobile (iOS e Android) in due versioni: IBLite free edition e l'avanzato InterBase ToGo edition
• Nuova libreria FireDAC per l'accesso universale ai dati che supporta tutti i maggiori RDBMS
• La nuova libreria REST client per connettersi con i servizi REST e le librerie cloud (sia per FMX che per VCL)
• Supporto ad iOS 7

Funzionalità e tecnologie previste per il 2014

Il tema principale per RAD Studio nel 2014 è l'aggiunta del supporto ad Android per C++ Builder ed in generale una forte spinta per la qualità, le performance e la stabilità del prodotto (QPS), un continuo avanzamento del supporto multi-piattaforma sia del designer sia del runtime, migliorie sulle librerie di remoting e architetture multi-tier e, ultimo ma non ultimo, nuovi componenti e nuove funzionalità nella VCL, vediamo l'elenco:

• Supporto per Android di C++ Builder
• QPS (Quality, Performance, Stability)
• Componenti per Advertising and Payments per le piattaforme Android e iOS
• Miglioramenti per la libreria middleware DataSnap (performance, REST mapping, architectural improvements)
• Ulteriori migliorie per supportare il paradigma del singolo sorgente su piattaforme multiple con un nuovo visual designer multi-device e nuovi componenti per l'interfacia utente
• Componenti per il "Mobile Backend as a Service" (MBaaS), che si interfacciano con alcuni provider di questi servizi, ad esempio Parse and Kinvey
• Interoperabilità tra applicazioni mobile e desktop!
• Supporto specifico per Android KitKat (4.4)
• Nuovo componente VCL per la Windows taskbar
• Miglioramenti sugli stili VCL e sul supporto delle applicazioni VCL sui tablet Windows Intel con componenti specifici per gli stili e per i sensori
• Supporto per i dispositivi indossabili Android (wearable devices) con particolari fattori di forma (vedi Google Glass)
• Supporto ai moduli Apache HTTP server per WebBroker e DataSnap, mantenendo ovviamente il supoprto ISAPI IIS
• Numerosi miglioramenti alla Run Time Library (RTL) implementati per tutte le piattaforme suportate, soprattutto nelle librerie XML, JSON e altre
• Nuovi driver database per FireDAC e miglioramenti in quelli esistenti, supporto per nuove versione dei database già supportati
• Supporto per le versioni future di Android e iOS che saranno annunciate da Google e Apple nel corso del 2014
• Supporto Bluetooth per i dispositivi mobile
• Una nuova release del compilatore C++ per Win32, con pieno supporto alle specifiche C++ 11

Il mio commento

Se Embarcadero conferma i due rilasci annuali, anche nel 2014 possiamo aspettarci 2 release di Delphi (RAD Studio) una in primavera e l'altra in autunno (le ipotizzo in base ai rilasci nel 2013 di XE4 e XE5) e quindi le features saranno spalmate sulle due release. Le mie preferite:

• QPS! Una release focalizzata sulla qualità, sulle performance (soprattutto relative alla nuova piattaforma FireMonkey) e sulla stabilità generale del prodotto non può che far piacere
• Migliorie per DataSnap sia come funzionalità che come performance
• Gestione semplifcata per dispositivi con diversi fattori di forma / risoluzioni
• Il supporto per dispositivi indossabili (Android) soprattutto per i Google Glass (è comunque già possibile compilare app per i GG anche con XE5)

Funzionalità e tecnologie previste dopo il 2014

• Supporto per le versioni future di Android e iOS
• Supporto per Linux (server-side) delle librerie DataSnap, WebBroker, RTL e database
• Dispositivi indossabili e HUDs (Head-up Displays), quando diverranno disponibili, incluso dispositivi Android con fattori di forma particolari e relative API
• Integrazione nativa e diretta con le nuove REST API, focalizzate in diverse aree dai sistemi automatizzati ai database NOSQL
• Compilatore Mac OS X 64bit
• Supporto per Windows 8 ARM/WinRT (Windows Phone e/o Windows RT desktop)
• Avamzamenti e aggiunte ai componenti BAAS e Cloud
• Supporto per le versioni future di Windows desktop che saranno annunciate nel 2014
• Completa e semplificata libreria per la programmazione multi-thread (parallel computing library) per sfruttare completamente le moderne architetture multi-core
• Android per la piattafroma Intel

Il mio commento

Le aree più interessanti (per me) sono il supporto a Linux (solo server-side) che include la libreria RTL ma anche WebBroker, FireDAC e soprattutto DataSnap, il supporto ai database NOSQL. Interessante anche la libreria per uno sviluppo multi-thread semplificato.

Altra piattaforma che seguo on interesse e che quindi vorrei veder supportata da Delphi è Android per Intel.

Non ci resta che aspettare il 2015 per vedere il futuro dello sviluppo cosa ci riserva!

Embarcadero Appmethod

Appmethod è un nuovo prodotto venduto (prossimamente) da Embarcadero che promette "Build Fast Apps Fast for Android, iOS, Windows and Mac". Se vi sembra che già esista uno strumento Embarcadero che fa esattamente queste cose, avete ragione ed il tool è RAD Studio (Delphi e C++ Builder).

Tecnicamente Appmethod condivide lo stesso IDE di Delphi e C++ Builder, la stessa libreria FM (FireMonkey), la stessa libreria di accesso ai dati, ecc... 

Sarà però possibile in Appmethod costruire solo applicazioni FireMonkey (FM) quindi non sarà presente il framework VCL e pertanto non sarà in alcun modo possibile ricompilare vecchie applicazioni Delphi basate, appunto, sulla VCL. Allo stesso modo non saranno presenti i framework COM, ActiveX il BDE e dbExpress.

Appmethod quindi si pone come soluzione per tutti quelli che devono costruire nuove applicazioni che sfruttino ad esempio le nuove tecnologie REST, SOAP e connettendosi a server middle-tier scritti con diversi strumenti.

Anche il modello di vendita si discosta nettamente da quello di Delphi, infatti oltre ad un'interessante versione free per singoli sviluppatori (con alcune limitazioni) è affiancata una versione individual/small team e una versione business che costeranno rispettivamente ($299/anno/sviluppatore/piattaforma) e ($999/anno/sviluppatore/piattaforma). La differenza tra le ultime due dovrebbero essere i servizi enterprise (Appmethod Enterprise Mobility Services). I servizi enterpise di appmethod possono essere classificati come MEAP, una serie di librerie che includono API Hosting, Data Access e Data Storage che possono servire per applicazioni mobile, desktop e web.

La mia personale opinione è che Appmethod non è solo una "ripacchettizazione" di RAD Studio, invece nell'ottica di nuovo sviluppo davvero multi-piattaforma (e soprattutto mobile) rappresenta un'offerta rivolta a tutti gli sviluppatori (al di fuori del mondo Delphi/C++ Builder) interessati a costruire in modo rapido e semplice applicazioni business per le diverse piattaforme (che ormai per noi utenti Delphi è una cosa normale!)

Links su Appmethod

Sito Appmethod

FAQ Appmethod per gli sviluppatori Delphi e C++ Builder

Articolo annuncio su TechCrunch

Hands-on su Engadget

Conclusioni

Di sicuro in Embarcadero non stanno con le mani in mano! Oltre ad inserire nuove funzionalità e supportare nuove piattaforme nel nostro Delphi e C++ Builder, cercano di allargare a tutti gli sviluppatori mondiali le tecnologie per la costruzione rapida di applicazioni multi-piattaforma creando nuove offerte e nuovi prodotti.

Delphi IDE Shortcuts!

Spesso mi capita di scrivere del codice a fianco di altri sviluppatori Delphi (durante alcune sessioni demo o durante lo sviluppo vero e proprio). Una cosa divertente è che quasi sempre capita che, alternandosi alla tastiera, ci si fermi un attimo per "rubarsi" a vicenda le combinazioni di tasti utilizzate per velocizzare alcune attività.

L'IDE di Delphi infatti nasconde un numero considerevole di shortcut utilissimi. Brian Long e Cary Jensen (due eminenti figure della comunità Delphi internazionale) hanno fatto lo sforzo di raccoglierli in un unico documento.

Vi lascio il link al post Delphi Editor Key Combination Table Updated del blog di Cary Jensen che contiene un link al documento PDF (da appendere vicino al monitor!).

La mia top five:

1. Ctrl + Shift + C, esegue class completion (funziona anche da implementation a interface!)
2. Ctrl + Shift + Su/Giù, per navigare fra codice (implementation) e dichiarazioni (interface)
3. Ctrl + Shift + J, avvia SyncEdit
4. Ctrl + T, elimina la parola a destra del cursore (io lo uso a fine riga, per eliminare le righe vuote)
5. Ctrl + Shift + T, aggiunge una voce TODO

Menzione speciale per il tasto F6 (o Ctrl + .) che invoca l'IDE Insight (utilissimo in varie occasioni).

A presto e buon lavoro!

Andrea 

Delphi Porte Aperte: grazie!

L'evento Delphi Porte Aperte organizzato da Wintech-Italia a Padova il 25 febbraio scorso è stato un successo: tanti sviluppatori Delphi erano presenti e interessati alle ultime novità introdotte nel nostro ambiente di sviluppo preferito!

Se, come da aspettative, abbiamo registrato un forte interesse per le funzionalità mobile offerte da Delphi XE5,  ottimo è stato anche il riscontro per la libreria FireDAC e per la sessione conclusiva di Paolo, sulle nuove funzionalità del linguaggio e dell'IDE.

Ringraziando tutti i partecipanti, ne approfittiamo per lasciarvi qualche fotografia scattata durante l'evento (grazie Lorenzo):

Link alla galleria

Vi ricordo che sono ancora aperte le iscrizioni per i prossimi corsi, che si terranno a Padova nelle prossime settimane:

• Mobile Lab: Progetta con noi la tua applicazione mobile, 17-18 marzo 2014
• Programmazione a Oggetti con Delphi, 19-20-21 marzo 2014

A presto!

Gli strumenti per potenziare l'IDE di Delphi (Parte 3 - CnPack)

Aggiornato Marzo 2016

La terza puntata di questa serie dedicata agli strumenti per potenziare l'IDE di Delphi prende in esame un nuovo interessante tool, CnPack

Nome:	CnPack
Sito:	http://www.cnpack.org/
Sito progetto:	https://github.com/cnpack/
Licenza:	Open Source
Prezzo:	0€

---

CnPack IDE Wizards è un insieme di strumenti per Delphi e C++ Builder compatibile con Delphi 5 - Delphi 10 Seattle e C++ Builder 5 - C++ Builder 10 Seattle tesi ad aumentare la produttività dell'IDE tramite "wizard" (così sono chiamati i singoli tool dal team di CnPack) e vari miglioramenti di diverse funzionalità.

Oltre ad essere gratuito è anche un progetto OpenSource ospitato su Google Code, quindi potete:

1. Modificare parti dei tool che non vi piacciono o implementare nuove funzionalità.
2. Migliorare la vostra conoscenza sulle Tools API e in generale sul codice ad un livello abbastanza elevato.

Menu

Come potete vedere dalla figura qui sotto i wizard (tool) di CnPack sono davvero numerosi.

In questo articolo, come nei precedenti presenterò una selezione (tuttavia abbastanza completa) di questi wizard che sono quelli che uso maggiormente io. Vi invito comunque ad esplorarli uno ad uno per trovare quelli che velocizzeranno maggiormente il vostro lavoro. La documentazione, nella forma di un file di Help agganciato alle finestre (invocabile con il classico F1) è molto buona soprattutto per un progetto Open Source.

Toolbars

Un aspetto interessante e da non sottovalutare sono le toolbar che vederete apparire una volta installato CnPack. Offrono i comandi accessibili in modo diretto ed intuitivo e soprattutto il vedercele davanti ci fanno ricordare che abbiamo a disposizione e a portata di "click" numerosissimi tool che ci offrono aiuto.

Source Highlight

Il cambiamento più evidente appena installato CnPack lo noterete aprendo un qualsiasi vostro sorgente.
Se avete unit (form) con codice con diversi cicli annidati, diversi costrutti if-then-else o istruzioni case complesse, provate ad aprirla e guardate di nuovo il codice... notate cambiamenti?

Come vedete nela figura sopra, tutti i blocchi di codice sono colorati in modo diverso e i begin..end sono uniti da linee (dello stesso colore) che mostrano alla prima occhiata l'indentazione e quindi il flusso del codice!

POtete notare anche l'evidenziazione di un identificatore (nell'esempio LSubIndex) che anche in questo caso mostra alla prima occhiata dove è stato usato

Come tutti i wizard di CnPack potete personalizzarne il comportamento e l'aspetto in modo significativo tramite la voce di menu Options, in questo caso potete  scegliere lo stile delle linee e il colore di evidenziazione degli identificatori (e se abilitare la funzionalità o meno).

Un inconveniente di questa funzionalità è che ovviamente richiede un certo tempo di calcolo e di rendering per mostrare la colorazione e l'evidenziazione e questo lo si può avvertire se avete unit di grandi dimensioni, proprio per questo potete notare l'ultima voce delle opzioni Disable Highlight when Unit Lines Exceeds che dice al wizard di disabilitare il syntax highlighting per le unit grandi dimensioni.

P.S.: Nel caso di unit "giganti" sarebbe opportuno provvedere ad una rifattorizzazione della stessa: imparate bene i comandi di refactoring e... via alle modifiche!

Form Design Wizard

La funzione più importante del Form Design Wizard, che potete avere anche come toolbar (molto più utile infase di design visuale), è quella di allineare, spostare e modificare i componenti sulla form, offrendo molte più opzioni rispetto alla toolbar di allineamento di Delphi.

Locate Components

Se avete form con molti componenti anche nascosti questa è l'utility che fa per voi, questa dialog vi consente infatti di cercare (filtrando per nome) tutti i componenti, visuali e non, che avete sul form. Una volta selezionato il componente dalla lista CnPack lo seleziona.

Convert to Code

Simile alla funzionalità "Components to Code" di GExperts questo wizard è utile per convertire un componente piazzato a design time in un blocco di codice per definirlo e inizializzarlo a run-time. La cosa in più rispetto a GExperts è la possibilità di copiare separatamente nella clipboard la definizione e l'inizializzazione. Anche il codice generato è migliore con commenti e soprattutto hanno evitato di usare il with, da molto considerato... il male!

Coding Toolset

I coding toolset sono per la maggior parte comandi che vi aiutano e assistono nella scrittura del codice, sono lanciati per lo più con tasti rapidi e quindi al prezzo di memorizzare altre scorciatoie da tastiera rendono alcune tra le più noiose operazioni quasi... divertenti!

Convert to String

Quante volte vi siete trovati nella condizione di dover riportare nel codice sorgente (ad esempio) uno statement SQL molto lungo e complesso? Sapete già che per formattarlo decentemente tra doppie virgolette, fine linea, indentazioni si spreca una quantità di tempo incredibile!

E se vi dicessi che CnPack ha un tool che fa esattamente questo?

La prima finestra mostra uno statement SQL scritto in un editor esterno la seconda immagine è presa da Delphi dopo che avevo incollato e convertito lo statement sopra, nessun altra operazione di editing è stata fatta!
Il tool in questione è il Convert to String che trovate sotto al menu Code Editor Wizard. Il tool è anche configurabile dalle opzioni di CnPack.

Eval Swap

Scambia le espressioni in un blocco di codice selezionato, ad esempio da A := B; a B := A; molto utile nei casi di load/save di dati (ad esempio da un dataset)

Toggle Uses/Include

Quando state scrivendo codice e avete bisogno di usare una funzione che si trova in una unit che non è ancora nelle clausole uses, il workflow più breve è questo: (se siete bravi ad usare i bookmark dell'IDE)

1. salvo il bookmark alla posizione corrente
2. vado in interface o implementation (se la unit è grande devo inoltre usare un cerca) 
3. scrivo la unit nella clausola la uses
4. ritorno al bookmark salvato
5. cancello il bookmark

Usando la funzionalità Toggle Uses/Include per arrivare allo stesso punto:

1. premo Ctrl-Alt-U 
2. scrivo il nome della unit da usare 
3. premo Esc ed è tutto fatto

Facile vero? Moltiplicate il tempo per le migliaia di volte che avete eseguito questa banale ma tediosa operazione e ditemi quanto tempo avreste risparmiato usando questo wizard! :-)

Toggle Var Field

Questa funzionalità e simile alla precedente solo dedicata alle variabili locali. Premete Ctrl-Shift-V e CnPack porta in cima alla funzione, se non c'è la parola chiave var, la aggiunge voi scrivete il nome ed il tipo della variabile e premendo Esc ritornate a lavorare.

Jump to Intf, Jump to Impl, Jump to Matched Keyword Tool 

Comandi comodi per saltare alla parte di interface/implementation di una unit, utile per gestire le clausole uses. I comandi sono invocabili anche dai pulsantini sulla toolbar.

Jump to Previous Identifier, Jump to Previous Identifier

Questa è un'altra funzione per cui vale la pena di installare CnPack (almeno per me). Usando Ctrl-Alt-Up e Ctrl-Alt-Down è possibile navigare all'interno di una unit selezionando l'identificatore (in realtà semplicemente una stringa di testo) precedente o successivo. Quindi se sono posizionato su una certa parola premendo Ctrl-Alt-Up mi sposterò nelle righe precedenti che contengono questa parola e premendo Ctrl-Alt-Down mi sposterò nelle righe successiveche contengono questa parola.

Con questa funzionalità l'uso della funziona ricerac si è drasticamente ridotto (nel mio caso) visto l'incredibile comodità di questo wizard.

Collector

Il collector è un utile strumento che consente di aver vari "snippet" di testo tutti in un unico posto, dimeticatevi di copie del notepad aperte e pezzi di codice che si perdono.. In collector potete avere più tab aperti, prendere codice dall'IDE e incollarlo nell'IDE.

MessageBox

Quando devi costruire le DialogBox non ti ricordi mai gli enumerativi dei pulsanti e delle icone? non ti ricordi le costanti dei valori di ritorno?

Beh allora devi proprio usare il wizard MessageBox di CnPack che visualmente ti aiuta a creare la tua Message Dialog senza impazzire tra opzioni e costanti impossibili da ricordare.

In aggiunta permette di scegliere tra diverse API per invocare la finestra: la MessageDlg di Delphi, Application. MessageBox oppure la MessageBox API, ovviamente pensa lui a cambiare tipo di parametri, effettuare conversioni di tipo ecc... tutto quello che dovete fare è premere il pulsante OK ed il codice apparirà come per incanto nell'editor.

Replace in Files

Ricercare e sostituire testo in file diversi non è mai stato così semplice. Con questo tool è possibile applicare trasformazioni di testo ad un insieme anche grande di file in un'unica operazione. Sebbene questo tool sia molto potente e  semplice da usare io preferisco il "Grep Search" di GExperts (vedi precedente articolo)

Tab Orders

Una corretta impostazione del Tab Order all'interno delle proprie form è molto importante per permettere all'utente di navigare da tastiera la nostra applicazione e riuscire ad effettuare data-entry il più velocemente possibile ma, ahimè, è anche molto facile dimenticarsi alla fine della progettazione della form di impostare correttamente l'ordine.

Il wizard Tab Orders di CnPack ci viene in aiuto in diversi modi:

Visualizzazione

Per visualizzare il numerino corrispondente all'ordine del controllo direttamente sul form la voce di menu è Display Tab Orders

Modifica

Per modificare l'ordine sulla form corrente, su tutte le form aperte o su tutte le form del progetto seguendo regole impostabile dal sottomenu Options. 

Auto aggiornamento

Per aggiornare automaticamente il Tab Order ogni volta che aggiungo un controllo sulla form dovete spuntare la voce di menu Auto Update Tab Orders

Con l'ausilio di questo tool non potete più dire di esservi scordati l'impostazione del Tab Order!

Source Templates

Con questo semplice tool è possibile applicare template, soprattutto per commenti, al sorgente. Esempi possono essere l'intestazione della unit oppure l'intestazione di procedure e funzioni ecc...

Convenzioni e stile di programmazione

Prima di introdurre il Prefix Wizard ritengo necessarie due parole su un aspetto importante (non solo in Delphi) ma spesso trascurato: le convenzioni per l'assegnazione dei nomi alle variabili, campi, classi e componenti, e più in generale lo stile di scrittura del codice sorgente, che non può e non deve essere lasciato al caso o alle preferenze personali (pure legittime) del singolo programmatore soprattutto se facente parte di un team.

L'argomento è piuttosto vasto ed intendo, prossimamente, scrivere un articolo dedicato, qui metterò invece i punti salienti.

Le "Coding Conventions" sono un insieme di regole o meglio ancora un insieme di linee guida che coprono: le convenzioni di nome per gli identificatori, la scrittura dei commenti, l'indentazione, ecc...
Il primo testo sull'argomento è stato pubblicato nel 1978, si chiama The Elements of Programming Style di Kernighan e Plauger ed il libro è una sorta di "introvabile" infatti le copie nuove arrivano fino a 200$!
Pur avendo una 30ina d'anni gli argomenti sono ancora di attualità visto che a distanza di tutto questo tempo la maggior parte dei programmatori continua a non seguirli!

Le principali regolette che enuncia il testo sono tutt'altro che complicate da mettere in pratica, le mie preferite:

1. Use variable names that mean something.
2. Format a program to help the reader understand it.
3. Write clearly, don't sacrifice clarity for efficiency
4. Let the machine do the dirty work.
5. Choose variable names that won't be confused.
6. Write first in easy-to-understand pseudo language; then translate into whatever language you have to use.
7. Modularize. Use procedures and functions. (e visto che Delphi è un linguaggio ad oggetti: classi)
8. Don't patch bad code -- rewrite it.
9. Test input for plausibility and validity.
10. Make sure all variables are initialized before use.
11. Make it right before you make it faster.
12. Make it fail-safe before you make it faster.
13. Make it clear before you make it faster.Don't strain to re-use code; reorganize instead.
14. Instrument your programs. Measure before making efficiency changes.
15. Make sure comments and code agree. :-)
16. Don't just echo the code with comments -- make every comment count.
17. Don't comment bad code -- rewrite it. (una delle mie preferite!)

e per ultimo quella che riesco a seguire:

1. Don't over-comment. (tranquilli, non mi capita mai! ;-) )

Se notate ai primi due posti ci sono le regole per il naming e di formattazione che sono le due regole che CnPack ci aiuta a seguire.

Come nominare le variabili e i componenti?

La notazione più famosa è la "Hungarian Notation" introdotta da Charles Simonyi diventato poi Chief architect in Microsoft (gli effetti di questa notazione li vediamo nel nome dei parametri della API Windows e nei tipi di dato del registry).
Sostanzialmente la regola dice di prefissare le variabili con il tipo del dato da esse rappresentato quindi lParam è un parametro di tipo long, szParam è un parametro di tipo stringa e così via...

Parlando di Delphi ritengo questa regola molto utile per nominare i componenti visuali messi sul form, meno per le variabili, i campi e le proprietà che a mio avviso devono seguire una differente notazione (il prefisso, IMO, deve indicare lo "scope" F per i campi di classe, L per le variabili locali, ecc... ma questo non è l'argomento di questo articolo).
Altra regola è quella di dare (oltre al prefisso) un nome "decente" ai vostri componenti, non avrete mica Button1..Button37 sulle vostre form vero?? :-)

Beh se così fosse troverete nel Prefix Wizard un valido alleato per aiutarvi a superare la tipica pigrizia del programmatore.

Prefix Wizard

Questa funzionalità penso sia la più amata e assieme la più odiata di CnPack. Il wizard permette di rinominare i componenti sul form per aggiungere un prefisso secondo regole impostabile dall'utente.
Le tre modalità di nomina dei componenti sono:

Prompt

Con le impostazioni di default una volta installato CnPack noterete che ogni volta che piazzate un controllo su una form vi appare una finestrella che vi chiede di impostare il nome del componente (e questa è la parte più odiata perchè, per chi installa CnPack e non conosce ancora la funzionalità, questi ulteriori passi sembrano un'inutile complicazione)
La prima finestra vi chiede di inputare il nome del componente mettendo un prefisso di default per il tipo di componente, se non vi piace il prefisso premete il pulsante Modify Prefix e lo cambiate ad questa dialog. 

Automatic

Nella finestra delle opzioni basta togliere il check alla voce Show Dialog when Add New Component or Rename e quando si mettono nuovi componenti sul form questi verranno automaticamente nominati.

Io non consiglio questa modalità perché benché i componenti abbiano il prefisso "giusto" questi verranno nominati (ad esempio per i pulsanti) btn1, btn2, ecc... vanificando l'obbiettivo di avere componenti con nomi "sensati" btnSalva, btnVerifica, ecc...

Manual

Il prefisso dei componenti si può cambiare manualmente, e soprattutto, processando tutti i componenti del form corrente, di tutte le form aperte o di tutte le form del progetto o del gruppo di progetti.

Una volta confermata questa dialog, se ci sono componenti da processare (che hanno prefisso diverso da quello voluto), vengono mostrati nella seguente finestra da dove è possibile variare anche il nome del componente stesso.

Property Corrector

Avere la connessione ad un database aperta a design-time è una delle feature più comode di Delphi (che altri importanti strumenti di programmazione hanno copiato solo nelle ultime versioni mentre i programmatori Delphi l'hanno usata fin dalla prima versione). Vedere i dati nelle griglie e negli altri controlli è davvero impagabile! Peccato che (almeno a me) è successo più di una volta (per mia disattenzione) di mandare al cliente l'applicativo che appena lanciato tenta di connettersi a localhost (o qualsiasi altro indirizzo usato per lo sviluppo) perchè ci siamo dimenticati di mettere a false la connection al database.

Con questo wizard è possibile processare tutti i componenti sulla form o su tutte le form del progetto e settare automaticamente le proprietà a valori voluti. Oltre alle connessioni database questo wizard può essere utile anche per settare la posizione delle form, o impostare in un sol colpo l'altezza dei pulsanti , ecc... 

Sebbene questo wizard sia utile e potente i GExperts hanno un tool simile che però viene invocato direttamente in compilazione e quindi ci solleva dalla responsabilità di ricordarci di lanciare il wizard.

Project Enhancements

Browse Current File's Dir, Browse Project Dir, Browse Output Dir

Comandi comodi per saltare direttamente ai folder più usati in un progetto.

List Units, List Forms, List Used

Altro wizard (per me) insostituibile. Le finestre che vedete sopra si sostituiscono alle dialog standard di Delphi View Unit (Ctrl-F12), View Form (Shift-F12).

Come potete notare già dalle schermate sono molto più potenti rispetto a quelle standard, supoprtano la ricerca inline, come testo contenuto o iniziale, permettono di filtrare l'elenco sul progetto attivo o su tutti i progetti del project group e molto altro.

Come dovete fare per invocarle? Nulla, quando installate i CnPack queste finestre vengono mostrate al posto di quelle standard ed invocate dalla stessa combinazione di tasti. Ovviamente potete disabilitarle e tornare alle precedenti... 

Ma perchè mai? :-)

Project Backup

Comodo per effettuare velocemente un backup di tutto il progetto, è possibile anche aggiungere file che non appartengono in senso stretto al codice sorgente.

Ricordo che comunque questo tool non è un rimpiazzo per un version control che rimane lo strumento principe per la gestione della storia del proprio codice sorgente.

Project CleanUp

Altro wizard molto comodo e di immediata comprensione, con in più la possibilità di non cancellare dcu/obj se non esistono i corrispondenti file sorgenti.

Project Dir Builder

Quando si hanno diversi progetti all'attivo è prassi comune standardizzasi su un layout di progetto pensato e ben definito, sfruttando poi la possibilità di Delphi di mettere nei path percorsi relativi un layout come quello che vedete in figura sopra (che solitamente adotto io per i miei progetti)  aiuta a rendere la gestione (version control, deployment, ecc...) operazioni gestibili automaticamente, quindi scriptabili, quindi automatizzabili.

Questo wizard permette di definire vari layout di progetto e poi applicarli ad una directory (creerà per voi tutta la struttura ad albero)

INI Reader & Writer (Menu Repository List)

Adesso uso sempre meno i file INI visto che da anni ho costruito classi che gestiscono la configurazione in XML dei miei applicativi ma quante volte avete scritto righe e righe di codice sempre uguale che legge/scrive i valori in un file INI? Se siete programmatori da più di qualche giorno il numero sicuramente è dell'ordine delle migliaia!

Questo wizard è in grado di prendere come input un normalissimo file INI con multiple sezioni, valori, ecc... e generare una unit pascal con una classe pronta all'uso solamente referenziando le proprietà (che ovviamente si chiameranno come le voci del file INI).
Avercelo avuto prima, vero? :-)

Explorer

Wizard molto comodo per avere smepre a fianco una vista sulle directory del progetto. La finestra è una finestra explorer-like e il click destro sugli elementi apre il normale menu contestuale di windows.

Historical File Snapshot

Permette di salvare i file più usati in un progetto e successivamente riaprirli senza tutte le volte aprirli manualmente uno per uno, soprattutto se i file da aprire non sono aggiunti alla lista del dpr ma sono solamente nel search path del progetto.

Procedure List

Parecchio utile per navigare il codice sorgente in modo potente e facile allo stesso tempo. In questo caso già i tasti rapidi di Delphi Ctrl-Shift-Up/Down rendono la navigazione nel codice sorgente davvero immediato ma questo expert aggiunge un'interfaccia visuale che a volte è comoda per "vedere" in un'unica occhiata i metodi di una classe.

Anche se altri tool hanno strumenti simili (i GExperts hanno appunto la "Procedure List") ma questo è a mio avviso il più completo e il più comodo.
In più questo wizard aggiunge la funzionalità anche alla toolbar per un uso ancora più immediato.

Uses Clean

Molto comodo quando si cambiano spesso componenti su un form. Si corre il rischio di includere unit non più necessarie, quindi ricordatevi di lanciare questo wizard almeno prima di effetuare le build definitive per fare un poco di pulizia.

IDE Enhancements

Code Input Helper

Una sorta di CodeComplete (a mio avviso più veloce e completo), funziona per tutti questi casi:

• When input in the uses section, all unit names available will be listed.
• Compiler directives. When input '{$', all compiler directives will be listed.
• Comments in XML Style. When input '///', all comment templates in XML Style will be listed.
• Comments in JavaDoc Style. When input '{*', all comment templates in JavaDoc Style will be listed.
• Code Templates defined in IDE. Such as trycf, forb and etc.
• User-defined identifiers, compiler directives, comment templates, code templates and etc.
• Macros are supported in code template.

Trovo insostituibile il completamento automatico nella scritture delle unit nelle uses (qui il completamento di Delphi non è così preciso e potente), nella scrittura delle direttive del compilatore (io uso parecchio le {$REGION ...} per comodità di lettura del sorgente) e nella scrittura dei TODO perchè digitando //t questo wizard mi prepara una riga TODO standard con data/ora utente e mi posiziona nel punto in cui devo inserire la descrizione.

Questo wizard è inoltre davvero molto configurabile con la dialog delle opzioni.

Editor Enhancements Wizard

Questo wizard contiene diverse funzionalità per arricchire l'editor, le toolbar, ecc...

Le opzioni sono davvero tante, vi consiglio di guardarle tutte perchè davvero possono aiutarvi a digitare codice molto più velocemente.

IDE Config Backup/Restore

Questo è un tool importantissimo perchè vi può salvare diverse ore di configurazione di una nuova installazione di Delphi e permette di effettuare un backup (in un formato binario) di tutti i settaggi dell'IDE di Delphi).

Questa operazione è in realtà molto semplice per chiunque abbia un minimo di dimestichezza con il Registry Editor di Windows, infatti basta salvare le chiavi di registro di Delphi a patto di conoscerne la locazione ed il significato (la gestione delle chiavi di registry di Delphi sarà oggetto di un prossimo articolo sul blog)   

Se invece non volete preoccuparvi di queste cose semplicemente usate questo Expert che in più vi da la possibilità di eliminare quelle chiavi usate solo per salvare la history dei file o delle operazioni fatte.

CnPack Options

Dopo anni di uso dei CnPack non ho (nemmeno lontanamente) visto e cambiato tutte le opzioni che mostrano le finestre dei settings! Divertitevi! :-)

Conclusioni

Ricordo ancora che i wizard di CnPack sono molti di più rispetto a quelli presentati in questo articolo, vi esorto a provarli per trovare quelli migliori per voi.

Nel prossimo articolo prenderemo in esame uno strumento che si occupa della gestione dei commenti/documentazione: DevJet DocumentInsight.

Se avete quesiti o proposte di recensione di altri tool scrivetemi o lasciate un commento su questo blog.