Pagine: 1 [2] 3 4 ... 14

Read More

Share on Twitter! Digg this story! Del.icio.us Share on Facebook! Technorati Reddit StumbleUpon
Quando si sviluppa una applicazione destinata ad avere un certo numero di form, è bene prevedere che tutte abbiamo lo stesso
comportamento. Se poi a lavorare sullo stesso progetto c'è più di uno sviluppatore allora un metodo comune di lavoro diventa
obbligatorio.
Solitamente si dice che si devono definire degli standard di sviluppo.

Read More

Share on Twitter! Digg this story! Del.icio.us Share on Facebook! Technorati Reddit StumbleUpon
In un'altro articolo (http://www.lazaruspascal.it/index.php?page=145) avevamo visto un po' di teoria relativamente a Advanced Record Syntax, ora proveremo un esempio pratico.

Quello che segue è il sorgente completo di un programmino da console che serve a fare un paio di test di questa caratteristica. Dopo il codice alcuni commenti.
Codice: [Seleziona]

program project1;

{$mode delphi}{$H+}
{$DEFINE USE_ADVANCED_RECORD_SYNTAX}

uses Classes;

type

  { TCliente }

  TCliente = record
  public
     type
       TIndirizzo = record
         Indirizzo: string[40];
         CAP: string[5];
         Citta: string[40];
         Prov: string[2];
       end;
       TTipoIndirizzo = (tiSedeOp, tiSedeLeg, tiSedeCon);
     var
       ID: integer;
       RagSociale: string[40];
       ParIva: string[13];

       SedeOperativa: TIndirizzo;
       SedeLegale: TIndirizzo;
       SedeConsegna: TIndirizzo;

     {$IFDEF USE_ADVANCED_RECORD_SYNTAX}
     procedure WriteIndirizzo(tipo: TTipoIndirizzo = tiSedeOp);
     {$ENDIF}
  end;

var Cliente: TCliente;

{ TCliente }

{$IFDEF USE_ADVANCED_RECORD_SYNTAX}
procedure TCliente.WriteIndirizzo(tipo: TTipoIndirizzo);
begin
   WriteLn(RagSociale);

   // test output
   case tipo of
      tiSedeLeg: if (SedeLegale.Indirizzo = '') and
                    (SedeLegale.CAP = '') and
                    (SedeLegale.Citta = '') and
                    (SedeLegale.Prov = '') then
                    tipo := tiSedeOp;
      tiSedeCon: if (SedeConsegna.Indirizzo = '') and
                    (SedeConsegna.CAP = '') and
                    (SedeConsegna.Citta = '') and
                    (SedeConsegna.Prov = '') then
                    tipo := tiSedeOp;
   end;

   // output
   case tipo of
      tiSedeOp: begin
                  Writeln(SedeOperativa.Indirizzo);
                  Writeln(SedeOperativa.CAP, ' - ' , SedeOperativa.Citta, ' (', SedeOperativa.Prov, ')');
      end;
      tiSedeLeg: begin
                  Writeln(SedeLegale.Indirizzo);
                  Writeln(SedeLegale.CAP, ' - ', SedeLegale.Citta, ' (', SedeLegale.Prov, ')');
      end;
      tiSedeCon:begin
                  Writeln(SedeConsegna.Indirizzo);
                  Writeln(SedeConsegna.CAP, ' - ', SedeConsegna.Citta, ' (', SedeConsegna.Prov, ')');
      end;
   end;
end;
{$ENDIF}


begin

  WriteLn('Test Advanced Record Syntax');
  Write('Advanced Record Syntax: ');
  {$IFDEF USE_ADVANCED_RECORD_SYNTAX}
  WriteLn('ON');
  {$ELSE}
  WriteLn('OFF');
  {$ENDIF}

  WriteLn('Size TCliente: ', SizeOf(Cliente));

  with Cliente do begin
     ID:= 1;
     RagSociale:='Lazarus Enterprises Inc.';
     ParIva := 'IT01234567890';

     With SedeOperativa do begin
        Indirizzo := 'Via dei mille nr. 999';
        CAP := '12345';
        Citta := 'Firenze';
        Prov := 'FI';
     end;

     With SedeConsegna do begin
        Indirizzo := 'Via dei bancali nr. 541';
        CAP := '55442';
        Citta := 'Ancona';
        Prov := 'AN';
     end;


  end;


  {$IFDEF USE_ADVANCED_RECORD_SYNTAX}
  Cliente.WriteIndirizzo(tiSedeLeg);
  {$ELSE}
  WriteLn(Cliente.RagSociale);
  Writeln(Cliente.SedeLegale.Indirizzo);
  Writeln(Cliente.SedeLegale.CAP, ' - ', Cliente.SedeLegale.Citta, ' (', Cliente.SedeLegale.Prov, ')');
  {$ENDIF}


end.




Le direttive
Sicuramente bisogna prestare attenzione alle direttive di questo sorgente.
La prima è da considerarsi obbligatoria in quanto questa caratteristica, almeno per ora, è stata implementata per compatibilità verso delphi e quindi bisogna impostare questo tipo di sintassi:
Codice: [Seleziona]
{$mode delphi}


La direttiva seguente:
Codice: [Seleziona]
{$DEFINE USE_ADVANCED_RECORD_SYNTAX}

Non è assolutamente obbligatoria, l'ho introdotta per meglio far comprendere alcuni aspetti di questa sintassi. Iniziamo quindi lasciando così questa direttiva.

Il record
Ho definito un tipo record per la gestione di una ipotetica tabella dei clienti. La dichiarazione inizia con:
Codice: [Seleziona]
TCliente = record

Notare che al suo interno ho nidificato un'altro tipo record:
Codice: [Seleziona]
TIndirizzo = record

in quanto più sotto ho bisogno di 3 campi dello stesso tipo (SedeOperativa, SedeLegale e SedeConsegna).
Notare soprattutto che se è attiva la direttiva USE_ADVANCED_RECORD_SYNTAX allora la procedura WriteIndirizzo  farà parte del record, esattamente come ci aspetteremmo per una classe.

La procedura WriteIndirizzo
Più sotto trovate il codice della procedura che non fa altro che, appunto, scrivere sulla console l'indirizzo richiesto. Si aspetta infatti un parametro (tipo indirizzo) però è fatta in modo che: se l'indirizzo è "sede legale" o "sede consegna" e se questo indirizzo non è mai stato fornito, allora viene scritto come default l'indirizzo "sede operativa". Ovviamente, nell'ipotetica applicazione, questo indirizzo è obbligatoriamente presente.

Eseguiamo con direttiva USE_ADVANCED_RECORD_SYNTAX
Se apriamo una console e lanciamo il programma, otteniamo il seguente output:
Codice: [Seleziona]
Test Advanced Record Syntax
Advanced Record Syntax: ON
Size TCliente: 332
Lazarus Enterprises Inc.
Via dei mille nr. 999
12345 - Firenze (FI)

Notare che l'indirizzo richiesto è la "sede legale" (Cliente.WriteIndirizzo(tiSedeLeg)) che non è mai stata fornita e a video troviamo la "sede operativa".
Notare anche la dimensione del record: 332 byte.

Eseguiamo senza direttiva USE_ADVANCED_RECORD_SYNTAX
Disabilitiamo ora la direttiva commentandola in questo modo:
Codice: [Seleziona]
// {$DEFINE USE_ADVANCED_RECORD_SYNTAX}  

e poi ricompiliamo il programma e lanciamolo nuovamente.
Otterremo il seguente output:
Codice: [Seleziona]
Test Advanced Record Syntax
Advanced Record Syntax: OFF
Size TCliente: 332
Lazarus Enterprises Inc.

 -  ()


Nel codice tradizionale si fa espressamente riferimento alla "sede legale" e non viene stampato nulla. Ovviamente avremmo potuto ovviare mettendo del codice "a mano", in modo tradizionale, all'interno del programma ed avremmo ottenuto lo stesso risultato. In questo modo però avremmo dovuto rinunciare all'incapsulazione ed a tutti i vantaggi che ne derivano.
Notare la dimensione del record, anche in questo caso: 332 byte. Esattamente come nell'altro caso.




Share on Twitter! Digg this story! Del.icio.us Share on Facebook! Technorati Reddit StumbleUpon
In questo articolo visioneremo i concetti basilari della programmazione per database con i componenti che permettono la visualizzazione dei contenuti di un campo appartenente al record selezionato di un datasource.

Nell'esempio che andremo a vedere prenderemo in considerazione SQLite come DBMS. La struttura SQL che useremo per il nostro esempio è la seguente.

CREATE TABLE "main"."" (
    "Id" INTEGER PRIMARY KEY AUTOINCREMENT,
    "Cognome" TEXT,
    "Nome" TEXT,
    "Citta" TEXT
);

Lazarus possiede molti package per poter lavorare con i DB, i due sicuramente più usati, mantenuti e testati sono: i componenti standard rilasciati con Lazarus stesso e ZeosLib.
Questo articolo prende in considerazione ZeosLib il quale permette un altissimo grado di astrazione del DBMS, cosa estremamente utile per non vincolare l'applicazione al DBMS. L'esempio che andremo a vedere vi permetterà di acquisire i rudimenti per impadronirvi dell'argomento.

Per prima cosa, creiamo una nuova applicazione tenendo in considerazione quanto imparato nei precedenti articoli sui database, quello che segue è il codice del nostro esempio

Codice: [Seleziona]

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, db, FileUtil, ZConnection, ZDataset, Forms, Controls,
  Graphics, Dialogs, DBGrids, DbCtrls, StdCtrls;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    DataSource1: TDataSource;
    DBEdit1: TDBEdit;
    DBGrid1: TDBGrid;
    DBMemo1: TDBMemo;
    DBNavigator1: TDBNavigator;
    DBText1: TDBText;
    ZConnection1: TZConnection;
    ZQuery1: TZQuery;
    Q_Inserimento: TZQuery;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    function GetLastId(): integer;
  private
    { private declarations }
  public
    { public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
var
   LastId: integer;
begin
     LastId:=Self.GetLastId()+1;
     Self.Q_Inserimento.SQL.Text:='INSERT INTO utenti(Id, Cognome,Nome,Citta)VALUES(' + IntToStr(LastId) + ',''Cognome' + IntToStr(LastId) + ''',''Nome' + IntToStr(LastId) + ''',''Città' + IntToStr(LastId) + ''');';
     Self.Q_Inserimento.ExecSQL;
     Self.ZQuery1.Refresh;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
     //svuoto la tabella
     Self.Q_Inserimento.SQL.Text:='DELETE FROM utenti;';
     Self.Q_Inserimento.ExecSQL;
     Self.ZQuery1.Refresh;
end;

function TForm1.GetLastId(): integer;
var
   ret: integer;
begin
     ret:=0;
     Self.Q_Inserimento.SQL.Text:='select Id as MaxId from utenti group by Id order by Id desc;';
     Self.Q_Inserimento.Open;
     if not Self.Q_Inserimento.EOF then
     begin
          Self.Q_Inserimento.First;
          ret:=Self.Q_Inserimento.FieldByName('MaxId').AsInteger;
     end;
     Self.Q_Inserimento.Close;
     result:=ret;
end;

end.


ma prendiamo in considerazione le singole parti

Andiamo a vedere la FormCreate, ovvero le azioni che vengono svolte dal programma alla creazione della form, nel nostro caso specifico la prima procedura che viene eseguita dal programma

Codice: [Seleziona]

procedure TForm1.FormCreate(Sender: TObject);
begin
     //svuoto la tabella
     Self.Q_Inserimento.SQL.Text:='DELETE FROM utenti;';
     Self.Q_Inserimento.ExecSQL;
     Self.ZQuery1.Refresh;
end;


come si può vedere andiamo a cancellare il contenuto della tabella usata nell'esempio.

Poi possiamo notare che abbiamo creato la seguente funzione
Codice: [Seleziona]

function TForm1.GetLastId(): integer;
var
   ret: integer;
begin
     ret:=0;
     Self.Q_Inserimento.SQL.Text:='select Id as MaxId from utenti group by Id order by Id desc;';
     Self.Q_Inserimento.Open;
     if not Self.Q_Inserimento.EOF then
     begin
          Self.Q_Inserimento.First;
          ret:=Self.Q_Inserimento.FieldByName('MaxId').AsInteger;
     end;
     Self.Q_Inserimento.Close;
     result:=ret;
end;

che permette di ottenere l'indice massimo contenuto nella griglia.
Nell'evento OnClick del pulsante Button1 andiamo ad inserire il codice che automaticamente aggiunge in maniera incrementale le singole righe della tabella basandosi sul risultato della funzione GetLastId visionata poco sopra.
Codice: [Seleziona]

procedure TForm1.Button1Click(Sender: TObject);
var
   LastId: integer;
begin
     LastId:=Self.GetLastId()+1;
     Self.Q_Inserimento.SQL.Text:='INSERT INTO utenti(Id, Cognome,Nome,Citta)VALUES(' + IntToStr(LastId) + ',''Cognome' + IntToStr(LastId) + ''',''Nome' + IntToStr(LastId) + ''',''Città' + IntToStr(LastId) + ''');';
     Self.Q_Inserimento.ExecSQL;
     Self.ZQuery1.Refresh;
end;


Poi successivamente andiamo ad impostare la proprietà ReadOnly a True nella DbGrid del nostro esempio in modo da non lasciare modificare i dati all'utente dalla DBGrid stessa.
Ora aggiungiamo al seguente esempio 3 componenti

    DBEdit1: TDBEdit;
    DBMemo1: TDBMemo;
    DBText1: TDBText;

Andiamo ad impostare per il componente DBEdit1 le seguenti proprietà:
DataSource: DataSource1
DataField: Nome

Andiamo ad impostare per il componente DBText1 le seguenti proprietà:
DataSource: DataSource1
DataField: Cognome

Andiamo ad impostare per il componente DBMemo1 le seguenti proprietà:
DataSource: DataSource1
DataField: Citta

Se eseguiamo il programma vedremo che in funzione del record su cui ci spostiamo possiamo visionare ma non modificare il campo Nome, mentre possiamo visionare e modificare i campi Cognome e Citta.

Qui trovate il link per scaricare l'esempio dell'articolo: www.lazaruspascal.it/esempi/Quarta_Applicazione.zip
Share on Twitter! Digg this story! Del.icio.us Share on Facebook! Technorati Reddit StumbleUpon
In questo articolo visioneremo i concetti basilari per usare le DBGrid in maniera professionale.

Partiamo subito dicendo che le DBGrid sono tra i componenti più usati e più comodi per lavorare con i database, permettono di sveltire di molto il lavoro dell'utente finale se sono usate correttamente. Le DBGrid necessitano di un solo parametro ovvero la voce DataSource che a sua volta punta ad un oggetto Query sia che si tratti dei componenti standard sia che si tratti di un componente ZeosLib.
Così otteniamo un uso standard della DBGrid, ma possiamo personalizzarla di molto usando un po' di codice, partiamo dall'esempio realizzato nell'articolo “DB concetti fondamentali e ZeosLib” e andiamo a modificare il database sqlite con il seguente codice:

-- Descrizione UTENTI
CREATE TABLE utenti (
    "Id" INTEGER,
    "Cognome" VARCHAR(50),
    "Nome" VARCHAR(50),
    "Citta" VARCHAR(50),
    "MyCheck" VARCHAR(50),
    "MyButton" VARCHAR(50),
    "MyPick" VARCHAR(50)
, "IdPickExternalKey" INTEGER)

-- Descrizione CHIAVEESTERNAPICK
CREATE TABLE "ChiaveEsternaPick" (
    "Id" INTEGER PRIMARY KEY AUTOINCREMENT,
    "Descrizione" TEXT
)

Come si può notare abbiamo aggiunto il campo IdPickExternalKey alla tabella principale in modo che faccia da chiave esterna e successivamente abbiamo creato una tabella apposita che contiene la chiave e il valore dei dati che vogliamo compaiano nella PickList (o combobox) che apparirà in una colonna della nostra DBGrid.

Ora aggiungiamo al progetto lazarus un componente TZQuery dal nome ZQuery2 e andiamo ad impostare i seguenti valori ai parametri:

Connection: ZConnection1
SQL: select * from chiaveesternapick;
Active: true

Successivamente aggiungiamo una nuova unit al progetto e inseriremo questo codice al suo interno:

Codice: [Seleziona]

{***********************************************************
*** Unit realizzata da Sammarco Francesco
*** per inserire delle combobox/picklist
*** all'interno della DBGrid. Sembra non funzionare con
*** tutti i tipi di DataSet, nel caso qualcuno riesca a
*** migliorare questa unit mi invii il codice migliorato
*** al seguente indirizzo: francesco.sammarco@gmail.com
***********************************************************}
unit Unit_CampoComboDBGrid;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, db, Grids;

function AddDBComboBoxToGrid(NomeNuovoCampo: string;MyDataSet: TDataSet; CampoDataSet: string ;DataSetList: TDataSet; ChiaveLista: string; CampoLista: string): boolean;

implementation

              function AddDBComboBoxToGrid(NomeNuovoCampo: string;MyDataSet: TDataSet; CampoDataSet: string ;DataSetList: TDataSet; ChiaveLista: string; CampoLista: string): boolean;
              var
                i: integer;
                ret: boolean;
                Field:TField;
              begin
                     ret:=false;
                     try
                        try
                           MyDataSet.FieldDefs.Update;
                           MyDataSet.Close;
                           for i:=0 to MyDataSet.FieldDefs.Count-1 do
                               if MyDataSet.FindField(MyDataSet.FieldDefs[i].Name) = nil then
                                  Field:=MyDataSet.FieldDefs[i].CreateField(MyDataSet);

                           if MyDataSet.FindField(NomeNuovoCampo)<>nil then
                              Exit;

                           Field:=TStringField.Create(MyDataSet);
                           with Field do
                           begin
                             FieldName:=NomeNuovoCampo;
                             Dataset:=MyDataSet;
                             FieldKind := fkLookup; //QUI DICO CHE E' UNA COMBOBOX
                             LookupDataSet:=DataSetList; //QUI ASSEGNO IL DATASET DA CUI EREDITARE I DATI DA FAR VEDERE NELLA COMBOBOX
                             LookupCache:=FALSE;
                             LookupKeyFields:=ChiaveLista;//'CHIAVE'; //CHIAVE CHE VERRA' INSERITA NEL CAMPO Temf.KeyFields
                             LookupResultField:=CampoLista;//'NOME'; //VALORE CHE VEDI NELLA COMBOBOX DA SELEZIONE
                             ReadOnly:=FALSE; //SOLA LETTURA
                             ProviderFlags:=[pfInUpdate, pfInWhere];
                             Required:=FALSE;
                             KeyFields:=CampoDataSet;//'CHIAVEPV';
                           end;
                           MyDataSet.Open;
                           ret:=TRUE;
                        finally
                       end;
                     except
                           on E: Exception do
                           begin

                           end;
                     end;
                     result:=ret;
              end;
end.


Bene con questa utilissima unit abbiamo messo i presupposti per proseguire nel nostro intento, ora manca una cosa sola, la seguente riga:

AddDBComboBoxToGrid('appoggio', Self.ZQuery1, 'IdPickExternalKey',Self.ZQuery2,'Id', 'Descrizione');

Che non fa altro se non dire di aggiungere alla griglia una nuova colonna (al fondo) di metterle come titolo della colonna la stringa 'appoggio' che riporta il valore del campo 'Descrizione' che ha come chiave di accoppiamento la colonna 'Id' e che entrambi i dati sono presenti nell'oggetto TZQuery (ma andrebbe benissimo ogni oggetto TdataSet) di nome ZQuery2, in modo tale da modificare automaticamente il valore presente nella colonna 'IdPickExternalKey' della fonte ovvero all'oggetto TZQuery (ma andrebbe benissimo ogni oggetto TdataSet) di nome ZQuery1.

Ma il nostro esempio non si ferma qui, vediamo inoltre come usare delle checkbox e altri utilissimi oggetti all'interno di una colonna (della Dbgrid).

             Self.DBGrid1.Columns.ButtonStyle:=cbsCheckboxColumn;
             Self.DBGrid1.Columns.ValueChecked:='TRUE';
             Self.DBGrid1.Columns.ValueUnchecked:='FALSE';

Come si può notare dal codice posto sopra andiamo a giocare con tre proprietà della colonna numero i (ovviamente i è un indice per scorrere tutte le colonne della griglia), che sono:

ButtonStyle: in cui andiamo a dire che forma possiederà la colonna, nel nostro caso andremo a dirgli che si tratta di una checkbox
ValueChecked: ovvero il valore che deve avere la colonna per apparire selezionata
ValueUncheked: ovvero il valore che deve avere la colonna per apparire deselezionata

Se invece avessimo voluto una picklist “fissa” che non facesse uso di chiavi esterne avremmo potuto usare il codice che segue:

               Self.DBGrid1.Columns.ButtonStyle:=cbsPickList;
               app:=TStringList.Create;
               app.Add('valore1');
               app.Add('valore2');
               app.Add('valore3');
               Self.DBGrid1.Columns.PickList:=app;
               app.Free;


Dove con
                Self.DBGrid1.Columns.ButtonStyle:=cbsPickList;      
andiamo a dire che vogliamo una picklist, mentre concetti
               app:=TStringList.Create;
               app.Add('valore1');
               app.Add('valore2');
               app.Add('valore3');
andiamo a creare una stringlist, ovvero una stringa di liste e gli aggiungiamo dentro tre stringhe, e con la seguente riga diciamo che la colonna deve presentare i valori della stringlist appena creata
               Self.DBGrid1.Columns.PickList:=app;

Ora creiamo l'evento FormCreate e inseriamo il seguente codice al nostro esempio

Codice: [Seleziona]

procedure TForm1.FormCreate(Sender: TObject);
var
   i: integer;
   app: TStringList;
begin
     for i:=0 to Self.DBGrid1.Columns.Count-1 do
     begin
          if Self.DBGrid1.Columns[i].FieldName='MyCheck' then
          begin
             Self.DBGrid1.Columns[i].ButtonStyle:=cbsCheckboxColumn;
             Self.DBGrid1.Columns[i].ValueChecked:='TRUE';
             Self.DBGrid1.Columns[i].ValueUnchecked:='FALSE';
          end
          else if Self.DBGrid1.Columns[i].FieldName='MyButton' then
          begin
               Self.DBGrid1.Columns[i].ButtonStyle:=cbsButton;
          end
          else if Self.DBGrid1.Columns[i].FieldName='MyPick' then
          begin
               Self.DBGrid1.Columns[i].ButtonStyle:=cbsPickList;
               app:=TStringList.Create;
               app.Add('valore1');
               app.Add('valore2');
               app.Add('valore3');
               Self.DBGrid1.Columns[i].PickList:=app;
               app.Free;
          end;
          //ora vado ad impostare una larghezza fissa per tutte le colonne della griglia
          Self.DBGrid1.Columns[i].Width:=100;
     end;
     //ora vado ad impostare la picklist ereditata da una query utilizzando la Unit chiamata Unit_CampoComboDBGrid
     AddDBComboBoxToGrid('appoggio', Self.ZQuery1, 'IdPickExternalKey',Self.ZQuery2,'Id', 'Descrizione');

     //ora vado ad impostare una larghezza fissa per tutte le colonne della griglia
     for i:=0 to Self.DBGrid1.Columns.Count-1 do
     begin
          Self.DBGrid1.Columns[i].Width:=100;
     end;

end;


otterremo così una griglia con una colonna checkbox, una colonna con la picklist fissa, ed una con una picklist variabile in funzione di quanto contenuto nell'apposita tabella. Il tutto con delle colonne tutte larghe 100.

Qui trovate il link per scaricare l'esempio dell'articolo: www.lazaruspascal.it/esempi/Terza_Applicazione.zip
Share on Twitter! Digg this story! Del.icio.us Share on Facebook! Technorati Reddit StumbleUpon
Pagine: 1 [2] 3 4 ... 14