Di seguito lo sviluppo di un algoritmo per la conversione di un numero arabo in numero romano. Il testo romano viene generato da destra a sinistra


//u_DaAraboARomano
//--------------------------

If (Count parameters=0)
      $romano:=u_DaAraboARomano (87) //per test
Else
      $number:=$1
      $udigits:="IVXLCDM"
      $romano:=""
      $posizione:=1
      Repeat
           $modulo:=$number%10
           If (($modulo%5)<4)
           For ($i;($modulo%5);1;-1)
           $romano:=$udigits[[$posizione]]+$romano
           End for
           End if
           If (($modulo>=4) & ($modulo<=8))
           $romano:=$udigits[[$posizione+1]]+$romano
           End if
           If ($modulo=9)
           $romano:=$udigits[[$posizione+2]]+$romano
           End if
           If ($modulo%5=4)
           $romano:=$udigits[[$posizione]]+$romano
           End if
           $number:=Trunc($number/10;0)
           $posizione:=$posizione+2
      Until ($number<=0)
      $0:=$romano
End if

// calcola il check digit del codice ean
    // se il codice ean è di 8 o 13 caratteri elimino un carattere e ricalcolo il check digit

C_TEXT($check;$ritorno;$codice)
C_COLLECTION($strParts)
C_LONGINT($lngIndex;$intTotal;$intCount;$intUp As;$elementi;$modoup)

If (Undefined($1))
  $0:=""
End if

If ($1="")
  $0:=""
End if

$codice:=$1

If (Length($codice)=13)
  $codice:= prendiSinistra($codice;12)
End if

If (Length($codice)=8)
  $codice:= prendiSinistra($codice;7)
End if

$codice:=$codice+"C"
$strParts:=Split string($codice;"")
$elementi:=$strParts.length

For ($lngIndex;$elementi-2;0;-2)
  For ($intCount;1;3)
    $intTotal:=$intTotal+Num($strParts[$lngIndex])
  End for
End for

$lngIndex:=13

For ($lngIndex;$elementi-1;0;-2)
  $intTotal:=$intTotal+Num($strParts[$lngIndex])
End for

$intUp:=$intTotal

Repeat
  $intUp:=$intUp+1
  $modoup:=Mod($intUp;10)
Until ($modoup=0)

$check:=String($intUp-$intTotal)

For ($lngIndex;0;$elementi-2)
  $ritorno:=$ritorno+$strParts[$lngIndex]
End for

$ritorno:=$ritorno+$check
$0:=$ritorno


Sotto il codice per le funzioni prendiSinistra/prendiDestra


---- prendiSinistra ------
    // $1=testo
    // $2=lunghezza
    // $0=testo left

If ($2=0)
$0:=""
End if

C_LONGINT($lungo)
$lungo:=Length($1)
If ($lungo=0)
$0:=""
End if

$0:=Substring($1;1;$2)

---- prendiDestra ----
    // $1=testo
    // $2=lunghezza
    // $0=testo right

If ($2=0)
  $0:=""
End if

$lunghezza:=Length($1)
If ($lunghezza=0)
  $0:=""
End if

$lunghezza:=Length($1)

$0:=Substring($1;$lunghezza-$2+1;$2)

Ritorna il numero in formato lettera come ad esempio per gli assegni bancari :
1234,56 = MilleDuecentoTrentaQuattro//56

C_TEXT($result;$risultato;$intero)

    // il dato passato è un numero double che devo trasformare in un formato italiano
$intero:=String($1;"###########0.00")
    // $intero:=$1 // importo in lettere
C_TEXT($resto)
C_LONGINT($lungo)
$lungo:=Length($intero)
C_LONGINT($decimale)
$decimale:=Position(",";$intero)
$resto:="/"+tright ($intero;2)
$intero:=tleft ($intero;$decimale-1)
C_TEXT($verifica)
$verifica:=Substring($intero;1;1)
If ($verifica="-")
  $intero=Mid(intero, 2)
End if
If ($1=0)
  $0="zero/00"
End if
C_LONGINT($mille)
$mille:=-1
C_LONGINT($k)
$k:=Mod(Length($intero);3)
If ($k#0)
  $intero=Repeate (3-$k,"0")+$intero
End if

While ($intero#"")
  $mille:=$mille+1
  C_TEXT($parziale;$tripla;$s)
  C_LONGINT($tv;$td; $tc)
  C_LONGINT($x;$y)

  $tripla:=tright ($intero;3)
  $intero:=tleft ($intero;Length($intero)-3)
  $tv:=Num($tripla)
  $td:=Mod($tv;100)
  $tc:=($tv-$td)/100
  If (Not($tc=0)
    $parziale:="cento"
    If ($tc>1)
      $parziale:=unita ($tc)+$parziale
    End if
  End if
  If ($td<20)
    $parziale:=$parziale+unita ($td)
  Else
    $x:=Mod($td;10)
    $y:=($td-$x)/10
    $parziale:=$parziale+decine ($y)
    $s:=unita ($x)
    $primoc:=tleft ($s;1)
    $instr:=Position($primoc;"uo";1)

    If ($instr#0)
      If ($s#"")
        If (Not$y=0)
          $parziale:=tleft ($parziale;Length($parziale-1))
        End if
      End if
    End if

    $parziale:=$parziale+$s
  End if
  $s:=migliaia ($mille)
  If ($mille>0)
    If ($parziale#"")

      $k:=$mille
      If ($parziale#"uno")
        $k:=$k+4
        $s:=migliaia ($k)
        $ddestra:=tright ($parziale;3)
        If ($ddestra="uno")
          $parziale:=tleft ($parziale;Length($parziale)-1)
          End if
      Else
        $parziale:=""
      End if
      $parziale:=$parziale+$s
    End if
  End if
  $result:=$parziale+$result
End while

If ($1<0)
$result="meno"+$result
End if

$0:=$result+$resto


E di seguito le varie altre funzioni utilizzate :

--- Repeate ---

C_TEXT($testo)
C_LONGINT($contatore)
For ($contatore;1;$1)
  $testo:=$testo+$2
End for

$0:=$testo

--- unita ---

C_COLLECTION($lettere)
C_TEXT($risultato)
$lettere:=Split string(",uno,due,tre,quattro,cinque,sei,sette,otto,nove,dieci,undici,dodici,tredici,quattordici,quindici,sedici,diciassette,diciotto,diciannove";",")

C_LONGINT($lunghezza)
$lunghezza:=$lettere.length

If ($1<0)
$risultato:=""
Else
If ($1>$lunghezza)
$risultato:=""
Else
$risultato:=$Lettere[$1]
End if
End if

$0:=$risultato

--- migliaia ---

C_COLLECTION($lettere)

C_TEXT($risultato)
$lettere:=Split string(",mille,unmilione,unmiliardo,millemiliardi,mila,milioni,miliardi,milamiliardi,milamiliardi,migliaiadimiliardi";",")

C_LONGINT($lunghezza)

$lunghezza:=$lettere.length
If ($1<0)
$risultato:=""
Else
If ($1>$lunghezza)
$risultato:=""
Else
$risultato:=$Lettere[$1]
End if
End if

$0:=$risultato

--- isnumeric ---

If (Undefined($1))
$0=False
End if

$lettera:=$1
$numero:=Num($lettera)
$letteranunero:=String($numero)

If (Substring($lettera;1;1)="0")
$letteranunero:="0"+$letteranunero
End if

If (Length($lettera)=Length($letteranunero)
$0:=True
Else
$0:=False
End if

--- decine ----

C_COLLECTION($lettere)
C_TEXT($risultato)
C_LONGINT($lunghezza)

$lettere:=Split string(",dieci,venti,trenta,quaranta,cinquanta,sessanta,settanta,ottanta,novanta";",")
$lunghezza:=$lettere.length

If ($1<0)
$risultato:=""
Else
If ($1>$lunghezza)
$risultato:=""
Else
$risultato:=$Lettere[$1]
End if
End if
$0:=$risultato

--- tleft ----
    
    // $1=testo
    // $2=lunghezza
    // $0=testo left

If ($2=0)
$0:=""
End if

C_LONGINT($lungo)
$lungo:=Length($1)
If ($lungo=0)
$0:=""
End if

$0:=Substring($1;1;$2)

--- tright ---
    // $1=testo
    // $2=lunghezza
    // $0=testo right

If ($2=0)
$0:=""
End if

$lunghezza:=Length($1)
If ($lunghezza=0)
$0:=""
End if

$lunghezza:=Length($1)

$0:=Substring($1;$lunghezza-$2+1;$2)

Questo metodo ritorna Vero se il codice fiscale passato è scritto correttamente, utilizzando il carattere di controllo finale. La procedura è un po' condensata: per l'algoritmo di controllo completo potete trovare il dettaglio sul sito del Ministero delle Finanze.

    `Metodo Controllo_CodiceFiscale
    `controlla il checksum del codice fiscale
    `Nexus srl 4-6-90
C_LONGINT($i;$n_l;$car_l;$cod_l)
C_STRING(16;$cf_s;$1)
C_STRING(43;$mysndcod_s)
$cf_s:=$1
If (Length($cf_s)#16)
  $0:=False
Else
  $n_l:=0
  For ($i;2;14;2)
    $car_l:=Ascii($cf_s[[$i]])
    Case of
      : (($car_l>=48) & ($car_l<=57))
        $cod_l:=$car_l-48
      : (($car_l>=65) & ($car_l<=90))
        $cod_l:=$car_l-65
      Else
        $cod_l:=0
    End case
    $n_l:=$n_l+$cod_l
  End for
  $mysndcod_s:="BAFHJNPRTVUMBERTOBAFHJNPRTVCESULDGIMOQKWZYX"
  For ($i;1;15;2)
    $car_l:=Ascii($cf_s[[$i]])-47
    $cod_l:=Ascii($mysndcod_s[[$car_l]])-65
    $n_l:=$n_l+$cod_l
  End for
  $0:=((65+$n_l-(Int($n_l/26)*26))=Ascii($cf_s[[16]]))
End if

La funzione per il calcolo del codice fiscale :
Nota : occorre il database con i comuni e relativi codici istat.

---- calcolocodicefiscale ----

    // dati da passare per il calcolo
    // $1:Nome;$2:Cognome;$3:data in formato testo;$4:sesso M o F;$5:codice istat comune
    // ritorno il codice fiscale
$nome:=$1
$cognome:=$2
$data:=$3
$sesso:=$4
$comune:=$5

$inome:=""
$icognome:=""
$icomune:=""
$controllo:=""
$temp:=""
$letteracod:=""
    //prendi le iniziali del nome
    //ccc As int32=1
$lungnome:=0
For ($lungnome;1;Length($nome))
$temp:=Lowercase(Substring($nome;$lungnome;1))
Case of
: $temp="b"
$inome:=$inome+$temp
: $temp="c"
$inome:=$inome+$temp
: $temp="d"
$inome:=$inome+$temp
: $temp="f"
$inome:=$inome+$temp
: $temp="g"
$inome:=$inome+$temp
: $temp="h"
$inome:=$inome+$temp
: $temp="j"
$inome:=$inome+$temp
: $temp="k"
$inome:=$inome+$temp
: $temp="l"
$inome:=$inome+$temp
: $temp="m"
$inome:=$inome+$temp
: $temp="n"
$inome:=$inome+$temp
: $temp="p"
$inome:=$inome+$temp
: $temp="q"
$inome:=$inome+$temp
: $temp="r"
$inome:=$inome+$temp
: $temp="s"
$inome:=$inome+$temp
: $temp="t"
$inome:=$inome+$temp
: $temp="v"
$inome:=$inome+$temp
: $temp="w"
$inome:=$inome+$temp
: $temp="x"
$inome:=$inome+$temp
: $temp="y"
$inome:=$inome+$temp
: $temp="z"
$inome:=$inome+$temp

End case

End for

If (Length($inome)>=4)
$temp:=Lowercase($inome)
$inome:=Substring($temp;1;1)+Substring($temp;3;1)+Substring($temp;4;1)
End if

    //controlla la lunghezza delle iniziali
If (Length($inome)>3)
$inome:=Substring($inome;1;3)
Else
If (Length($inome)<3)
For $lungnome(1;Length($nome))
$letteracod:=Substring($nome;$lungnome;1)
Case of
: $letteracod="a"
$inome:=$inome+"a"
: $letteracod="e"
$inome:=$inome+"e"
: $letteracod="i"
$inome:=$inome+"i"
: $letteracod="o"
$inome:=$inome+"o"
: $letteracod="u"
$inome:=$inome+"u"
End case
End for

If (Length($inome)>3)
$inome:=Substring($inome;1;3)
If (Length($inome)<3)
For ($lungnome;Length($inome);3)
$inome:=$inome+"x"
End for
End if
End if
End if
End if

    // prendi lettere del cognome
For ($lungnome;1;Length($cognome))
$temp:=Lowercase(Substring($cognome;$lungnome;1))
Case of
: $temp="b"
$icognome:=$icognome+$temp
: $temp="c"
$icognome:=$icognome+$temp
: $temp="d"
$icognome:=$icognome+$temp
: $temp="f"
$icognome:=$icognome+$temp
: $temp="g"
$icognome:=$icognome+$temp
: $temp="h"
$icognome:=$icognome+$temp
: $temp="j"
$icognome:=$icognome+$temp
: $temp="k"
$icognome:=$icognome+$temp
: $temp="l"
$icognome:=$icognome+$temp
: $temp="m"
$icognome:=$icognome+$temp
: $temp="n"
$icognome:=$icognome+$temp
: $temp="p"
$icognome:=$icognome+$temp
: $temp="q"
$icognome:=$icognome+$temp
: $temp="r"
$icognome:=$icognome+$temp
: $temp="s"
$icognome:=$icognome+$temp
: $temp="t"
$icognome:=$icognome+$temp
: $temp="v"
$icognome:=$icognome+$temp
: $temp="w"
$icognome:=$icognome+$temp
: $temp="x"
$icognome:=$icognome+$temp
: $temp="y"
$icognome:=$icognome+$temp
: $temp="z"
$icognome:=$icognome+$temp
End case
End for

    // controlla la lunghezza delle iniziali
If (Length($icognome)>3)
$icognome:=Substring($icognome;1;3)
Else
If (Length($icognome)<3)
// minore di tre cifre prendi anche le vocali
For ($lungnome;1;Length($cognome))
letteracod:=Substring($cognome;$lungnome;1)
Case of
: $letteracod="a"
$icognome:=$icognome+"a"
: $letteracod="e"
$icognome:=$icognome+"e"
: $letteracod="i"
$icognome:=$icognome+"i"
: $letteracod="o"
$icognome:=$icognome+"o"
: $letteracod="u"
$icognome:=$icognome+"u"
End case
End for

If (Length($icognome)>3)
$icognome:=Substring($icognome;1;3)
Else
If (Length($icognome)<3)
For ($lungnome;Length($icognome);3)
$icognome:=$icognome+"x"
End for
End if
End if
End if
End if

    // Dim idata, gg, mm, aa As String
    // temp=data
    // Dim tempn As string

ARRAY TEXT($ddata;0)
C_COLLECTION($detta)

$detta:=Split string($data;"/")
COLLECTION TO ARRAY($detta;$ddata)

$gg:=$ddata{1}
$mm:=$ddata{2}
If (Length($ddata{3})=2)
$aa:=$ddata{3}
Else
$aa:=Substring($ddata{3};3;2)
End if

$idata:=$aa
    //MsgBox("TEMP"+temp)
Case of
: $mm="01"
$idata:=$idata+"a"
: $mm="02"
$idata:=$idata+"b"
: $mm="03"
$idata:=$idata+"c"
: $mm="04"
$idata:=$idata+"d"
: $mm="05"
$idata:=$idata+"e"
: $mm="06"
$idata:=$idata+"h"
: $mm="07"
$idata:=$idata+"l"
: $mm="08"
$idata:=$idata+"m"
: $mm="09"
$idata:=$idata+"p"
: $mm="10"
$idata:=$idata+"r"
: $mm="11"
$idata:=$idata+"s"
: $mm="12"
$idata:=$idata+"t"
End case
If ($sesso="M")
$idata:=$idata+$gg
Else
If ($sesso="F")

$idata:=$idata+String(Num($gg)+40)
End if
End if

C_LONGINT($vdis)

    // codice parziale per calcolare ultima cifra
$parz:=Lowercase($icognome+$inome+$idata+$comune)
    // trova il carattere di verificca
For ($lungnome;1;15;2)
$d:=Substring($parz;$lungnome;1)
Case of
: $d="0"
$vdis:=$vdis+1
: $d="1"
$vdis:=$vdis+0
: $d="2"
$vdis:=$vdis+5
: $d="3"
$vdis:=$vdis+7
: $d="4"
$vdis:=$vdis+9
: $d="5"
$vdis:=$vdis+13
: $d="6"
$vdis:=$vdis+15
: $d="7"
$vdis:=$vdis+17
: $d="8"
$vdis:=$vdis+19
: $d="9"
$vdis:=$vdis+21
: $d="a"
$vdis:=$vdis+1
: $d="b"
$vdis:=$vdis+0
: $d="c"
$vdis:=$vdis+5
: $d="d"
$vdis:=$vdis+7
: $d="e"
$vdis:=$vdis+9
: $d="f"
$vdis:=$vdis+13
: $d="g"
$vdis:=$vdis+15
: $d="h"
$vdis:=$vdis+17
: $d="i"
$vdis:=$vdis+19
: $d="j"
$vdis:=$vdis+21
: $d="k"
$vdis:=$vdis+2
: $d="l"
$vdis:=$vdis+4
: $d="m"
$vdis:=$vdis+18
: $d="n"
$vdis:=$vdis+20
: $d="o"
$vdis:=$vdis+11
: $d="p"
$vdis:=$vdis+3
: $d="q"
$vdis:=$vdis+6
: $d="r"
$vdis:=$vdis+8
: $d="s"
$vdis:=$vdis+12
: $d="t"
$vdis:=$vdis+14
: $d="u"
$vdis:=$vdis+16
: $d="v"
$vdis:=$vdis+10
: $d="w"
$vdis:=$vdis+22
: $d="x"
$vdis:=$vdis+25
: $d="y"
$vdis:=$vdis+24
: $d="z"
$vdis:=$vdis+23
End case
End for

C_LONGINT($vpar)

For ($lungnome;2;14;2)
$p:=Substring($parz;$lungnome;1)
Case of
: $p="0"
$vpar:=$vpar+0
: $p="1"
$vpar:=$vpar+1
: $p="2"
$vpar:=$vpar+2
: $p="3"
$vpar:=$vpar+3
: $p="4"
$vpar:=$vpar+4
: $p="5"
$vpar:=$vpar+5
: $p="6"
$vpar:=$vpar+6
: $p="7"
$vpar:=$vpar+7
: $p="8"
$vpar:=$vpar+8
: $p="9"
$vpar:=$vpar+9
: $p="a"
$vpar:=$vpar+0
: $p="b"
$vpar:=$vpar+1
: $p="c"
$vpar:=$vpar+2
: $p="d"
$vpar:=$vpar+3
: $p="e"
$vpar:=$vpar+4
: $p="f"
$vpar:=$vpar+5
: $p="g"
$vpar:=$vpar+6
: $p="h"
$vpar:=$vpar+7
: $p="i"
$vpar:=$vpar+8
: $p="j"
$vpar:=$vpar+9
: $p="k"
$vpar:=$vpar+10
: $p="l"
$vpar:=$vpar+11
: $p="m"
$vpar:=$vpar+12
: $p="n"
$vpar:=$vpar+13
: $p="o"
$vpar:=$vpar+14
: $p="p"
$vpar:=$vpar+15
: $p="q"
$vpar:=$vpar+16
: $p="r"
$vpar:=$vpar+17
: $p="s"
$vpar:=$vpar+18
: $p="t"
$vpar:=$vpar+19
: $p="u"
$vpar:=$vpar+20
: $p="v"
$vpar:=$vpar+21
: $p="w"
$vpar:=$vpar+22
: $p="x"
$vpar:=$vpar+23
: $p="y"
$vpar:=$vpar+24
: $p="z"
$vpar:=$vpar+25
End case

End for

    // somma dei valori ottenuti dal dispari e dal pari
$vdisparsomma:=$vdis+$vpar
    // ---------------------
    // vdisparsomma=148
    // ---------------------
    // diviso 26, troviamo il resto
$restov:=Mod($vdisparsomma;26)

Case of $restov
: $restov=0
$controllo:="a"
: $restov=1
$controllo:="b"
: $restov=2
$controllo:="c"
: $restov=3
$controllo:="d"
: $restov=4
$controllo:="e"
: $restov=5
$controllo:="f"
: $restov=6
$controllo:="g"
: $restov=7
$controllo:="h"
: $restov=8
$controllo:="i"
: $restov=9
$controllo:="j"
: $restov=10
$controllo:="k"
: $restov=11
$controllo:="l"
: $restov=12
$controllo:="m"
: $restov=13
$controllo:="n"
: $restov=14
$controllo:="o"
: $restov=15
$controllo:="p"
: $restov=16
$controllo:="q"
: $restov=17
$controllo:="r"
: $restov=18
$controllo:="s"
: $restov=19
$controllo:="t"
: $restov=20
$controllo:="u"
: $restov=21
$controllo:="v"
: $restov=22
$controllo:="w"
: $restov=23
$controllo:="x"
: $restov=24
$controllo:="y"
: $restov=25
$controllo:="z"
End case
    // fai il codice fiscale
$codicefiscale:=Uppercase($parz+$controllo)
$0:=$codicefiscale

// ritorna i dati da una tabella non correlata
    // $1 campo, $2 chiave, $3 tabella, $4 $filtro

C_TEXT($campo) // è il campo che utilizzo per la ricerca
C_TEXT($chiave) // è la chiave cioè il campo che voglio sia ritornato
C_TEXT($tabella) // è il nome della tabella per la quale voglio effettuare la ricerca
C_TEXT($filtro) // eventuale filtro WHERE
C_TEXT($risultato)
$campo:=$1
$chiave:=$2
$tabella:=$3
$filtro:=$4

SQL LOGIN(SQL_INTERNAL;"";"")

C_LONGINT($ffiltro)
$ffiltro:=Position($filtro;"%")
If ($ffiltro>0)
  $filtro:=Char(Quote)+$filtro+Char(Quote)
  SQL EXECUTE("SELECT DISTINCT "+$chiave+" FROM "+$tabella+" WHERE "+$campo+" LIKE "+$filtro;$risultato)
Else
  $filtro:=Char(Quote)+$filtro+Char(Quote)
  SQL EXECUTE("SELECT DISTINCT "+$chiave+" FROM "+$tabella+" WHERE "+$campo+" = "+$filtro;$risultato)
End if

SQL LOAD RECORD(SQL all records)
SQL LOGOUT

$0:=$risultato{0}

Il presente codice serve per ricavare il codice binario del codice 2 of 5 per poter poi disegnare il barcode in SVG (0) linea sottile, (1) linea spessa

C_TEXT($K)
C_TEXT($strCode)
C_TEXT($strAux)
C_TEXT($strExit)

$strCode:=$1
$strAux:=$strCode

If ($strCode="")
$0:=""
End if

For ($K=1;(Length($strCode))
C_TEXT($codice)
$codice:=Substring($strAux;$K;1)
Case of
: $codice="0"
: $codice="1"
: $codice="2"
: $codice="3"
: $codice="4"
: $codice="5"
: $codice="6"
: $codice="7"
: $codice="8"
: $codice="9"
: $codice="@"
: $codice="§"
// ok il codice non contiene caratteri non validi
Else
Alert("Errore il codice interleave 2 of 5 contiene caratteri non ammessi, sono ammessi solo numeri da 0-9)
$0:=""
End case
End for

For($K;1;length($strCode))
C_TEXT($codice)
$codice:=Substring($strCode;$K;1)
Case of
: ="1"
$strExit:=$strExit+"11010010010110"
: ="2"
$strExit:=$strExit+"11010101001100"
: ="3"
$strExit:=$strExit+"11001010100110"
: ="4"
$strExit:=$strExit+"11010010100110"
: ="5"
$strExit:=$strExit+"10110100100110"
: ="6"
$strExit:=$strExit+"10011010101100"
: ="7"
$strExit:=$strExit+"10110010101100"
: ="8"
$strExit:=$strExit+"10011001010110"
: ="9"
$strExit:=$strExit+"10110100101100"
: ="0"
$strExit:=$strExit+"11001010010110"
: ="@"
$strExit:=$strExit+"10110010110010"
: ="§"
$strExit:=$strExit+"11010000000000"
End case
// salto
End for

$0:=$strExit

Funzione utile per ricavare una stringa come questa riferita al codice EAN 13 o EAN 8 : 00010100011010100111000110100100010100111010001101010111001011011001001110101110010100001101100101000

è possibile poi dividere la stringa e disegnare con SVG linee verticali di spessore normale (0) e spessore doppio (1) per ricavare l'immagine del barcode.

$1 è il codice EAN ( se è lungo 12 o 7 caratteri inserire anche il metodo checkdigit, lo trovate in questo forum).

C_LONGINT($K)
C_TEXT($strAux)
C_TEXT($strExit)
C_TEXT($strCode)
C_TEXT($strEANCode)
$strAux:=$1
$strEANCode:=$1

    // se ho passato il codice ean senza check digit lo calcolo
If (Length($strAux)=12)
  $strEANCode:=Ean138CheckDigit ($strEANCode)
Else
  If (Length($strAux)=7)
    $strEANCode:=Ean138CheckDigit ($strEANCode)
  End if
End if

$strAux:=$strEANCode

If (Not(isnumeric ($strAux)))
  ALERT("Attenzione, il barcode contiene caratteri non validi")
  $0:=""
End if


If (Length($strAux)=13)
      // verifico che sia un EAN 13
      // per prima cosa scarto la prima cifra che è lo stato di emissione(fare riferimento ad INDICOD '
  $strAux:=Substring($strAux;2)
  C_LONGINT($numero)
  $numero:=Num(tleft ($strEANCode;1))
  Case of
    : $numero=0
      $strCode:="000000"
    : $numero=1
      $strCode:="001011"
    : $numero=2
      $strCode:="001101"
    : $numero=3
      $strCode:="001110"
    : $numero=4
      $strCode:="010011"
    : $numero=5
      $strCode:="011001"
    : $numero=6
      $strCode:="011100"
    : $numero=7
      $strCode:="010101"
    : $numero=8
      $strCode:="010110"
    : $numero=9
      $strCode:="011010"
  End case
Else
  $strCode:="0000"
End if

    //
    //Il codice EAN inizia con un carattere iniziale
    //
$strExit:="000101"

    //
    //Prima metà del codice
    //
For ($K;1;Length($strAux)\2)
  
  C_TEXT($code)
  C_LONGINT($numero)
  
  $code:=Substring($strCode;$K;1)
  $numero:=Num(Substring($strAux;$K;1))
  Case of
    : $numero=0
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0001101"
      Else
        $temptext:="0100111"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=1
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0011001"
      Else
        $temptext:="0110011"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=2
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0010011"
      Else
        $temptext:="0011011"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=3
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0111101"
      Else
        $temptext:="0100001"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=4
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0100011"
      Else
        $temptext:="0011101"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=5
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0110001"
      Else
        $temptext:="0111001"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=6
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0101111"
      Else
        $temptext:="0000101"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=7
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0111011"
      Else
        $temptext:="0010001"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=8
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0110111"
      Else
        $temptext:="0001001"
      End if
      $strExit:=$strExit+$temptext
      
    : $numero=9
      C_TEXT($temptext)
      If ($code="0")
        $temptext:="0001011"
      Else
        $temptext:="0010111"
      End if
      $strExit:=$strExit+$temptext
      
  End case
End for

    //
    // Prosegue poi con un separatore di mezzo
    //

$strExit:=$strExit+"01010"

    //
    // Seconda metà del codice
    //

For ($K;Length($strAux)\2+1;Length($strAux))
  C_LONGINT($numero)
  $numero:=Num(Substring($strAux;$K;1))
  Case of
    : $numero=0
      $strExit:=$strExit+"1110010"
    : $numero=1
      $strExit:=$strExit+"1100110"
    : $numero=2
      $strExit:=$strExit+"1101100"
    : $numero=3
      $strExit:=$strExit+"1000010"
    : $numero=4
      $strExit:=$strExit+"1011100"
    : $numero=5
      $strExit:=$strExit+"1001110"
    : $numero=6
      $strExit:=$strExit+"1010000"
    : $numero=7
      $strExit:=$strExit+"1000100"
    : $numero=8
      $strExit:=$strExit+"1001000"
    : $numero=9
      $strExit:=$strExit+"1110100"
  End case
End for

    // Il Codice EAN finisce con un separatore finale

$strExit:=$strExit+"101000"

$0:=$strExit

Gli sconti composti sono gli sconti commerciali ad esempio 50+20+3 oppure 50+20-3 ( applico lo sconto del 50+20 con un amento del 3% ).

per l'utilizzo :
$importoscontato:=scontocommerciale(126.34,"50+20+3")

--- scontocommerciale ---

    // ricava lo sconto in base alla stringa
    // $1 importo
    // $2 sconto
    // ritorno l'importo scontato su $0

If ($2="")
  If ($1=0)
    $0:=0
  Else
    $0:=$1
  End if
End if


$scontotxt:=$2
$scontotxt:=Replace string($scontotxt;"+";"§+")
$scontotxt:=Replace string($scontotxt;"-";"§-")

C_COLLECTION($sconti)
ARRAY TEXT($ssconti;0)
C_REAL($importoscontato;$scontopercento)

$sconti:=Split string($scontotxt;"§")
COLLECTION TO ARRAY($sconti;$ssconti)

$elementi:=Size of array($ssconti)
$importoscontato:=$1

For ($contatore;1;$elementi)
  $scontopercento:=Num($ssconti{$contatore})
  $sconto:=$importoscontato*$scontopercento/100
  $importoscontato:=$importoscontato-$sconto
End for

$0:=$importoscontato

Con il comando SET DATABASE PARAMETER e il parametro Circular log limitation si può gestire il massimo numero di file di log dia tenere in rotazione automatica per tipo di log.

Il numero passato limita il numero di file presenti, con la cancellazione automatica del più vecchio. Si applica a:

- request logs (selectors 28 and 45),
- debug log (selector 34),
- events log (selector 79)
- Web request logs and Web debug logs (selectors 29 and 84 of the WEB SET OPTION command).

Il default è 0 che registra tutti i file senza limiti (finché c'è spazio su disco...)

Per 4DTEXT, 4DHTML, 4DEVAL c'è una sintassi alternativa veramente comoda.

Con la v16 è possibile usare per questi tag la forma con il $:
$4dtag (espressione) al posto del solito

Questo va bene solo per questi tag:
4DTEXT
4DHTML
4DEVAL

Quindi ad esempio:
$4DTEXT(UserName)

invece di:
<!--#4DTEXT UserName-->

Questo è l'elenco aggiornato dei TAG da usare nelle pagine dinamiche ( o da Web o col comando PROCESS 4D TAGS) :

4DTEXT, inserisce variabili o espressioni di 4D come testo (se contengono un carattere come il < lo traducono in htmlencode per visualizzarlo cosi com'è)

4DHTML, inserisce variabili o espressioni di 4D come codice HTML, senza conversioni

4DEVAL, valuta espressioni di 4D, anche senza risultato ( tipo a:=1 ), nel caso ritorni lo considera come HTML senza sostituzioni di caratteri

4DSCRIPT, esegue un metodo 4D (in fase di preparazione della pagina, non arriva sul browser) con la sintassi &lt;!--#4DSCRIPT/metodo/mioparametro--&gt; : The method does not exist.
Nota: il metodo deve essere flaggato come disponibile per il web, aver dichiarato come testo $0 e $1, e in $1 riceverà "/mioparametro"

4DINCLUDE, include un'altra pagina (in fase di preparazione della pagina, non arriva sul browser)

4DBASE, definisce da quel punto in avanti dove prendere le pagine con i 4DINCLUDE successivi

4DCODE, esegue blocchi di codici 4D anche su più righe, incluse finestre e il comando Trace: è eseguito lato server prima di servire la pagina

4DIF, 4DElse, 4DElseIF e 4DENDIF, per gestire condizioni,

4DLOOP and 4DENDLOOP, per fare cicli di codice. Adesso accetta:
- array ( incluso array di puntatori)
- tabella (la selezione corrente)
- espressione, in cui esce dal ciclo per una condizione classica, del tipo:
<!--#4DEVAL $i:=0-->
<!--#4DLOOP ($i<4)-->
<!--#4DEVAL $i-->
<!--#4DEVAL $i:=$i+1-->
<!--#4DENDLOOP-->

Nelle stringhe JSON i caratteri da filtrare sono:

virgolette (quote) -> \"
barra a destra (slash) -> \/
barra a sinistra (backslash) -> \\
backspace -> \b
formfeed -> \f
nuova linea (new line, char(10) ) -> \n
a capo (return, char(13) ) -> \r
tabulatore (tab, char(9) ) -> \t
tutti i caratteri da 0 a 31 esclusi quelli sopra devono diventare \x00-\x1F
un qualsiasi carattere unicode -> \u+4 cifre esadecimale


// web_jsonEncode

$risultato:=$1

$risultato:=Replace string($risultato;"\\";"\\\\")
$risultato:=Replace string($risultato;char(double quote);"\\\"")
$risultato:=Replace string($risultato;"/";"\\/")
$risultato:=Replace string($risultato;Char(Backspace);"\\b")
$risultato:=Replace string($risultato;Char(FF ASCII code);"\\f")
$risultato:=Replace string($risultato;Char(Line feed);"\\n")
$risultato:=Replace string($risultato;Char(Carriage return);"\\r")
$risultato:=Replace string($risultato;Char(Tab);"\\t")

$0:=$risultato

E' un classico registrare in coppie di array impostazioni o valori da tenere in memoria.

Tipicamente sono due array, si cerca nel primo e se si trova si prende il valore dal secondo, così:

// PER REEGISTRARE
ARRAY TEXT(preferenzeChiave;3)
ARRAY TEXT(preferenzeValore;3)
preferenzeChiave{1}:="Valuta"
preferenzeValore{1}:="Euro"
preferenzeChiave{2}:="Iva"
preferenzeValore{2}:="22"
preferenzeChiave{3}:="Spese"
preferenzeValore{4}:="2,00"

// PER RIPRENDERE
$ce=Find in array(preferenzeChiave;"Iva")
If ($ce>0)
  $0:= preferenzeValore{$ce}
Else
  $0:=""
End if

Con il nuovo Tipo C_OBJECT le due cose si possono scrivere così:

// PER REEGISTRARE
C_OBJECT(oPreferenze)
OB SET(oPreferenze;"Valuta";"Euro";"Iva";22;"Spese";2.00)

// PER RIPRENDERE
$iva:=OB GET(oPreferenze;"Iva")

Nelle form impostando un oggetto di Variabile con il contenuto di un Object si ottiene:
1- la visualizzazione del Json corrispondente (senza dover usare JSON stringify)
2- il Json può essere modificato dall'utente e la variabile si aggiorna!

Quando si usa JSON Stringify o Selection to JSON i campi time vengono trasformati in un numero intero di millisecondi dalla mezzanotte.

Quindi le 10 del mattino diventano 10*3600*1000 = 36 000 000

Per recuperare l'orario originale si possono fare due cose:


$millisec:=36000000

Se mi serve una Stringa:
$testo:=Time String($millisec/1000)
-> $testo = "10:00:00"

Se mi serve un Time:
$ora:=Time($millisec/1000)
-> $ora = ?10:00:00?

Il comando Selection to JSON crea una stringa JSON con i campi della selezione corrente, ad esempio:

$jsonString :=Selection to JSON([Anagrafica])

Il risultato sarà del tipo :
[
{"cognome":"Rossi", "nome":"Mario"},
{"cognome":"Verdi", "nome":"Giuseppe"},
...
]

E' possibile caricare solo alcuni campi aggiungendoli alla sintassi:

$jsonString :=Selection to JSON([Anagrafica], [Anagrafica]Cognome)
[
{"Cognome":"Rossi"},
{"Cognome":"Verdi"},
...
]


Oppure si può impostare un "template"

  C_OBJECT($template)
  OB SET($template;"LastName";->[Anagrafica] Cognome)
  $jsonString :=Selection to JSON([Anagrafica];$template)

[
{"LastName":"Rossi"},
{"LastName":"Verdi"},
...
]

Partendo da una variabile C_Object si ottiene l'equivalente in stringa JSON con il comando

JSON Stringify ( value ; * ) -> ritorna una stringa compatta
JSON Stringify ( value ; * ) -> modalità 'pretty print', ritorna una stringa indentata

Esempio:

C_OBJECT($Anagrafica;$Figli)
  OB SET($Anagrafica;"cognome";"Rossi";"nome";"Mario")
  OB SET($Figli;"nome";"Giovanni";"anni";"12")
  OB SET($Anagrafica;"figli";$Figli)
  $Uno:=JSON Stringify($Anagrafica)

  {"nome":"Mario","cognome":"Rossi","figli":{"nome":"Giovanni","anni","12"}}

$Due:=JSON Stringify($Anagrafica;*)
  
  {
  "nome":"Mario",
  "cognome":"Rossi",
  "figli":{
    "nome":"Giovanni",
    "anni","12"
  }
}

Dalla versione v14 sono disponibili i comandi JSON, che permettono di passare da stringhe a oggetti 4d.

Gli oggetti JSON sono circondati da graffe {}
Gli array sono circondati da quadre []
I dati sono in formato "chiave":"valore"
La sequenza di dati è separata dalle virgole

Il valore può essere:

• testo (fra virgolette)


• numero (col punto decimale)


• data ( "YYYY-MM-DDTHH:mm:ssZ" )


• true/false


• null

JSON Parse ( jsonString {; type} ) -> Function result

Se viene passato il parametro il comando lo converte nel formato richiesto, altrimentii farà la conversione al meglio possibile. Due esempi:

JSON Parse("{\"nome\":124}") -> ritorna un C_OBJECT con {nome = 124}
JSON Parse("{\"nome\":124}", is longint) -> ritorna 124

Ecco un esempio di codice per la creazione di un foglio Excel usando il plugin free e opensource scritto da Miyako:

https://github.com/miyako/4d-plugin-xls

$text:=Unicode_sample

    //create a workbook
$book:=XLS WORKBOOK Create

$sheetName:=$text
$sheet:=XLS WORKBOOK Create sheet ($book;$sheetName)

    //problem with Mac version of Excel 2010; OK on Windows
XLS WORKSHEET SET COL WIDTH ($sheet;0;20*256)

$row:=0 //zero-based
$col:=0 //zero-based
$format:=0 //NULL=default format (0x0F)
$cell:=XLS WORKSHEET Set cell text ($sheet;$row;$col;$format;$text)
XLS CELL RELEASE ($cell) //we don't need this reference any more, so release it.

    //create a range reference node
$cell1:=XLS WORKSHEET Set cell real ($sheet;0;1;$format;1)
$cell2:=XLS WORKSHEET Set cell real ($sheet;1;1;$format;2)
$area:=XLS WORKBOOK Create area node ($book;$cell1;$cell2;XLS_CELL_ABSOLUTE_As1;XLS_CELLOP_AS_REFERENCE)
XLS CELL RELEASE ($cell1)
XLS CELL RELEASE ($cell2)

    //create a function node
$fn:=XLS WORKBOOK Create fn1 node ($book;XLS_FUNC_SUM;$area)
$cell:=XLS WORKSHEET Set cell fn ($sheet;2;1;$format;$fn)
XLS NODE RELEASE ($fn)
XLS NODE RELEASE ($area)
XLS CELL RELEASE ($cell)

XLS WORKSHEET RELEASE ($sheet)

$success:=XLS WORKBOOK Save document ($book;System folder(Desktop)+$text+".xls")

XLS WORKBOOK CLEAR ($book)

COOKIE LAW
      1) Che cosa sono i cookie?
I cookie sono dei file di testo che i siti visitati inviano al browser dell'utente e che vengono memorizzati per poi essere ritrasmessi al sito alla visita successiva.

      2) A cosa servono i cookie?
I cookie possono essere usati per monitorare le sessioni, per autenticare un utente in modo che possa accedere a un sito senza digitare ogni volta nome e password e per memorizzare le sue preferenze.

      3) Cosa sono i cookie tecnici?
I cookie cosiddetti tecnici servono per la navigazione e per facilitare l'accesso e la fruizione del sito da parte dell'utente. I cookie tecnici sono essenziali per esempio per accedere a Google o a Facebook senza doversi loggare a tutte le sessioni. Lo sono anche in operazioni molto delicate quali quelle della home banking o del pagamento tramite carta di credito o per mezzo di altri sistemi.

      4) I cookie Analytics sono cookie tecnici?
In altri termini i cookie che vengono inseriti nel browser e ritrasmessi mediante Google Analytics o tramite il servizio Statistiche di Blogger o similari sono cookie tecnici?. Il Garante ha affermato che questi cookie possono essere ritenuti tecnici solo se "utilizzati a fini di ottimizzazione del sito direttamente dal titolare del sito stesso, che potrà raccogliere informazioni in forma aggregata sul numero degli utenti e su come questi visitano il sito. A queste condizioni, per i cookie analytics valgono le stesse regole, in tema di informativa e consenso, previste per i cookie tecnici."

      5) Che cosa sono i cookie di profilazione?
Sono cookie utilizzati per tracciare la navigazione dell'utente per creare profili sui suoi gusti, sulle sue preferenze, sui suoi interessi e anche sulle sue ricerche. Vi sarà certamente capitato di vedere dei banner pubblicitari relativi a un prodotto che poco prima avete cercato su internet. La ragione sta proprio nella profilazione dei vostri interessi e i server indirizzati opportunamente dai cookie vi hanno mostrato gli annunci ritenuti più pertinenti.

      6) È necessario il consenso dell'utente per l'installazione dei cookie sul suo terminale?
Per l'installazione dei cookie tecnici non è richiesto alcun consenso mentre i cookie di profilazione possono essere installati nel terminale dell'utente solo dopo che quest'ultimo abbia dato il consenso e dopo essere stato informato in modo semplificato.

      7) In che modo gli webmaster possono richiedere il consenso?
Il Garante per la Privacy ha stabilito che nel momento in cui l'utente accede a un sito web deve comparire un banner contenente una informativa breve, la richiesta del consenso e un link per l'informativa più estesa come quella visibile in questa pagina su che cosa siano i cookie di profilazione e sull'uso che ne viene fatto nel sito in oggetto.

      8) In che modo deve essere realizzato il banner?
Il banner deve essere concepito da nascondere una parte del contenuto della pagina e specificare che il sito utilizza cookie di profilazione anche di terze parti. Il banner deve poter essere eliminato solo con una azione attiva da parte dell'utente come potrebbe essere un click.

      9) Che indicazioni deve contenere il banner?
Il banner deve contenere l'informativa breve, il link alla informativa estesa e il bottone per dare il consenso all'utilizzo dei cookie di profilazione.

      10) Come tenere documentazione del consenso all'uso dei cookie?
È consentito che venga usato un cookie tecnico che tenga conto del consenso dell'utente in modo che questi non abbia a dover nuovamente esprimere il consenso in una visita successiva al sito.

      11) Il consenso all'uso dei cookie si può avere solo con il banner?
No. Si possono usare altri sistemi purché il sistema individuato abbia gli stessi requisiti. L'uso del banner non è necessario per i siti che utilizzano solo cookie tecnici.

      12) Che cosa si deve inserire nella pagina informativa più estesa?
Si devono illustrare le caratteristiche dei cookie installati anche da terze parti. Si devono altresì indicare all'utente le modalità con cui navigare nel sito senza che vengano tracciate le sue preferenze con la possibilità di navigazione in incognito e con la cancellazione di singoli cookie.

      13) Chi è tenuto a informare il Garante che usa cookie di profilazione?
Il titolare del sito ha tale onere. Se nel suo sito utilizza solo cokie di profilazione di terze parti non occorre che informi il Garante ma è tenuto a indicare quali siano questi cookie di terze parti e a indicare i link alle informative in merito.

      14) Quando entrerà in vigore questa normativa?
Il Garante ha dato un anno di tempo per mettersi in regola e la scadenza è il 2 Giugno 2015.

COOKIE UTILIZZATI IN QUESTO SITO
File di log: Come molti altri siti web anche questo fa uso di file di log registra cioè la cronologia delle operazioni man mano che vengono eseguite. Le informazioni contenute all'interno dei file di registro includono indirizzi IP, tipo di browser, Internet Service Provider (ISP), data, ora, pagina di ingresso e uscita e il numero di clic. Tutto questo per analizzare le tendenze, amministrare il sito, monitorare il movimento dell'utente dentro il sito e raccogliere dati demografici, indirizzi IP e altre informazioni. Tale dati non sono riconducibili in alcun modo all'identità dell'utente e sono cookie tecnici.

COOKIE DI TERZE PARTI PRESENTI NEL SITO

Cookie: www.sviluppo4d.it usa i cookie per memorizzare le informazioni sulle preferenze dei visitatori e sulle pagine visitate dall'utente e per personalizzare il contenuto della pagina web in basa al tipo di browser utilizzato e in funzione delle altre informazioni che appunto tale browser invia.

1) Cookie Google: tale cookie è stato introdotto da Google cinque anni fa e serve per pubblicare annunci Adsense su www.sviluppo4d.it in modo da mostrare all'utente della pubblicità più mirata in base alla loro cronologia. Gli utenti possono accettare tale cookie oppure disattivarlo nel loro browser visitando la pagina Privacy e Termini. Ulteriori informazioni sulle tipologie e sull'uso che fa Google dei cookie con finalità pubblicitarie possono essere trovate nella pagina web dei Tipi di cookie utilizzati. Anche alcuni partner pubblicitari di Google Adsense possono usare cookie e Web Beacons per tracciare gli utenti.

2) Cookie di Facebook: Questo sito ha alcuni plugin di Facebook che possono tracciare il comportamento dei lettori. Per avere maggiori informazioni si può consultare la pagina per la
Politica della Privacy di Facebook.

3) Google+ attraverso lo script plusone.js potrà trattare i dati personali secondo queste line guida
Google Cookie Policy Privacy

In questo blog hanno accesso server di terze parti o di rete pubblicitarie che usano tale tecnologia per inviare gli annunci nel tuo browser attraverso www.sviluppo4d.it. Tramite il rilevamento del tuo indirizzo IP mostrano la pubblicità più pertinente con i tuoi interessi. Tecnologie simili (quali cookie, web bacons e javascript) possono essere utilizzati dalle reti pubblicitarie di terze parti per misurare l'efficacia dei loro messaggi pubblicitari e per personalizzare il contenuto di tali messaggi.

Il sito www.sviluppo4d.it e il suo amministratore non hanno alcun controllo sui cookie che vengono utilizzati da terze parti quindi per approfondire il tema si consiglia di consultare le politiche della privacy di queste terze parti così come le opzioni per disattivare la raccolta di queste informazioni. L'amministratore di questo sito non può quindi controllare le attività degli inserzionisti di questo blog. È comunque possibile disabilitare i cookie direttamente dal proprio browser.

Queste disposizioni del Garante della Privacy non sono solo italiane ma sono comuni a gran parte del paesi europei. Si possono conoscere le regole di ciascuna giurisdizione consultando il sito Your Online Choices nella propria lingua.

UTILIZZO DI GOOGLE ANALYTICS IN QUESTO SITO
Come detto i cookie analytics sono considerati tecnici se utilizzati solo a fini di ottimizzazione e se gli IP degli utenti sono mantenuti anonimi. Informiamo l'utente che questo sito utilizza il servizio gratuito di Google Analytics. Ricordiamo che i dati vengono usati solo per avere i dati delle pagine più visitate, del numero di visitatori, i dati aggregati delle visite per sistema operativo, per browser, ecc. Gli IP di Google Analytics sono stati anonimizzati. Questi parametri vengono archiviati nei server di Google che ne disciplina la Privacy secondo queste linee guida.

Un utente può disattivare Google Analytics durante la navigazione utilizzando il componenete aggiuntivo disponibile per Chrome, Firefox, Internet Explorer, Opera e Safari.

Si possono inoltre
cancellare i cookie singolarmente per ciascun dominio,
nascondere le ricerche.
settare le impostazioni degli annunci di Google.

NAVIGAZIONE ANONIMA

Una navigazione senza l'utilizzo di cookie tecnici e di profilazione è possibile mediante quella che viene definita navigazione in incognito e che è fattibile con tutti i principali browser.
Ulteriori informazioni sulla disabilitazione dei cookie su Firefox, in inglese.
Ulteriori informazioni sulla disabilitazione dei cookie su Chrome, in inglese
Ulteriori informazioni sulla disabilitazione dei cookie su Internet Explorer, in inglese
Ulteriori informazioni sulla disabilitazione dei cookie su Safari , in inglese
Ulteriori informazioni sulla disabilitazione dei cookie su Opera, in inglese.

Le librerie OpenSSL usate da 4d e 4d server e il corrispondente supporto a TLS sono i seguenti:

4D openSSL TLS supportato
12.x : 0.9.8j : TLS v1.0
13.x : 1.0.0.d : TLS v1.0
14.x : 1.0.0.d : TLS v1.0

Dalla versione v12 queste sono le posizioni dei file di preferenza:

WINDOWS
C:\Users\\AppData\Roaming\4D\
C:\Users\\AppData\Roaming\4D Server\

MAC
erano per la v12:
/Users//Library/Preferences/4D/
adesso sono:
/Users//Library/Application Support/4D/ /Users//Library/Application Support/4D Server/


Le posizioni delle finestre e altre dimensioni si trovano:

WINDOWS
C:\Users\Administrator\AppData\Roaming\4D\4D Window Bounds v14\

MAC
/Users//Library/Application Support/4D/4D Window Bounds v14/

Dalla versione 13.5 4d non salverà più i record che hanno il flag di unico, ma che non hanno un indice assegnato.

Questa procedura permette l'estrazione dalla struttura dei campi unici non indicizzati
cfr http://kb.4d.com/assetid=77024


C_LONGINT($maxTableNumber_l;$currentTable_l)
C_LONGINT($maxFieldCount_l;$currentField_l)
C_LONGINT($dontCare_l) // Per valori GET FIELD PROPERTIES non usati.
C_BOOLEAN($dontCare_f;$isIndexed_f;$isUnique_f)
C_TEXT($logHeader_t;$logRecord_t;$logfile_t)
C_TEXT($delim_t;$lf_t)
C_TIME($logfile_h)
C_TEXT($tableName_t;$fieldName_t;$note_t)

$delim_t:=Char(Tab)
$lf_t:=Char(Carriage return)+Char(Line feed)

$logHeader_t:="Campi unici senza indice:"+$lf_t

$logfile_t:=Get 4D folder(Logs Folder)+"UniciNonIndicizzati"

$logfile_h:=Create document($logfile_t)

If (OK=1)

  SEND PACKET($logfile_h;$logHeader_t)

  $maxTableNumber_l:=Get last table number

  For ($currentTable_l;1;$maxTableNumber_l)
    If (Is table number valid($currentTable_l))
      $maxFieldCount_l:=Get last field number(Table($currentTable_l))
      For ($currentField_l;1;$maxFieldCount_l)
        If (Is field number valid($currentTable_l;$currentField_l))

           // Nota che la seguente riga è spezzata in due:
          GET FIELD PROPERTIES($currentTable_l;$currentField_l;$dontCare_l;\
           $dontCare_l;$isIndexed_f;$isUnique_f;$dontCare_f)

          If (($isUnique_f) & (Not($isIndexed_f)))

           $tableName_t:=Table name(Table($currentTable_l))
           $fieldName_t:=Field name(Field($currentTable_l;$currentField_l))

           $logRecord_t:="["+$tableName_t+"]"+$fieldName_t+$lf_t

           SEND PACKET($logfile_h;$logRecord_t)

          End if
        End if
      End for
    End if
  End for

  CLOSE DOCUMENT($logfile_h)
  SHOW ON DISK($logfile_t)
End if

Quando si usa 4D come Web server, normalmente si risponde con le normali pagine come richieste dall'utente con un leader di default (= 200)

Quando invece bisogna rispondere con una pagina che non è quella richiesta, la cosa migliore per rispondere ai casi eccezionali sarebbe quella di mettere il corretto header.

Ad esempio, se l'url non è riconosciuto puoi mandare l'utente alla pagina che vuoi, dovresti impostare questo header

ARRAY TEXT($atHeaders;2)
ARRAY TEXT($atValues;2)
$atHeaders{1}:="X-VERSION"
$atValues{1}:="HTTP/1.1"
$atHeaders{2}:="X-STATUS"
$atValues{2}:="404 Not Found"
WEB SET HTTP HEADER($atHeaders;$atValues)
WEB SEND FILE("pagina_errore.html")

Un altro header utile:
"302 Moved Temporarily" (equivalente al redirect) cfr http://www.sviluppo4d.it/Detail_Faq_Display?ID=632&title=Alternativa+al+comando+SEND+HTTP+REDIRECT

Per una funzione non disponibile si dovrebbe usare:
"501 Not implemented"

Da notare che usualmente si vedono due tipi di errore gestiti automaticamente da 4D Web Server:
"500 Internal server error" : il codice ha incontrato una condizione non prevista, di solito errore puro
"503 Service Unavailable" : hai superato il numero di richieste contemporanee accettate ( di solito legato ad un parametro di configurazione )

Qui l'elenco ufficiale:
http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

Su Mac OS X 10.9 Maverick le applicazioni che non sono davanti (in 'foreground') vengono automaticamente abbassate di priorità con la nuova funzione "App Nap".

Questo è ovviamente un problema se il 4d Server viene usato su un 10.9: in questo caso basta andare nella finestra Info del Finder per l'app Server e impostare il flag "Impedisci App Nap"

E' possibile scrivere il testo di un pulsante in modo che venga visualizzato su due righe. Non bisogna usare il classico Carriage Return, bensì il carattere "\" ("\\" nel code editor).

Questa caratteristica è utilizzabile solo su 3D button, 3D radio button e 3D check box.

Se si sceglie di effettuare manualmente il backup con il metodo:

CONFIRM("Eseguo il salvataggio automatico?";"Sì";"No")
If (OK=1)
  BACKUP
End if

Se la destinazione non è disponibile (ad esempio una pen drive) 4D modifica il percorso di backup con la cartella della struttura.
Se si salva in un file BackupSave.xml la copia della configurazione corretta, si può modificare il metodo precedente così:

CONFIRM("Eseguo il salvataggio automatico?";"Sì";"No")
If (OK=1)
  DELETE DOCUMENT(getPathname (Structure file)+"Preferences\\Backup\\Backup.xml")
  COPY DOCUMENT(getPathname (Structure file)+"Preferences\\Backup\\BackupSave.xml";u_PathnameOnly (Structure file)+"Preferences\\Backup\\Backup.xml")
  BACKUP
End if

Il comando SET DATABASE PARAMETER con l'opzione 64 (SSL Cipher List) permette di impostare il livello di cifratura SSL.

Ad esempio è possibile eseguire questo codice per disabilitare l'SSL2 e attivare solo l'SSL3 per la versione di 4d v11:

STOP WEB SERVER
SET DATABASE PARAMETER (SSL Cipher List;"HIGH:!SSLv2:!EXP:!ADH:!aNULL:!eNULL:!NULL")
START WEB SERVER

Alcune informazioni su come scrivere questo parametro si può leggere la documentazione del Comando Ciphers di OpenSSL.

Nella v13.3 i valori di default sono:
TLSv1/SSLv3, Cipher : AES256-SHA AES(256)

Le altre cifrature accettate sono
SSL2 ciphers: nessuno

SSL3 ciphers:
CAMELLIA256-SHA 256 bit
AES256-SHA 256 bit
DES-CBC3-SHA 168 bit
SEED-SHA 128 bit
CAMELLIA128-SHA 128 bit
AES128-SHA 128 bit
IDEA-CBC-SHA 128 bit
RC4-SHA 128 bit
RC4-MD5 128 bit
DES-CBC-SHA 56 bit

TLS1 ciphers:
CAMELLIA256-SHA 256 bit
AES256-SHA 256 bit
DES-CBC3-SHA 168 bit
SEED-SHA 128 bit
CAMELLIA128-SHA 128 bit
AES128-SHA 128 bit
IDEA-CBC-SHA 128 bit
RC4-SHA 128 bit
RC4-MD5 128 bit
DES-CBC-SHA 56 bit

Nelle installazioni Client/Server 4D registra in locale delle risorse che velocizzano i collegamenti successivi e che sono automaticamente aggiornati senza che l'utente debba intervenire.

Dalla v11 la posizione di queste risorse è in cartelle registrate in queste posizioni:

Windows XP:
{Disco:}\Documents and Settings\{nome_utente}\Local Settings\Application Data\Nomeprogramma_indirizzo

Windows Vista/7
{Disco:}\Users\{nome_utente}\AppData\Local\4D\Nomeprogramma_indirizzo

Mac
{Disco}Users\{nome_utente}\Libreria\Cache\4D\Nomeprogramma_indirizzo


Nel caso in cui il client è incorporato nell'applicazione, le cartelle locali sono:

Windows Vista/7
{Disk}:\Users\{nome_utente}\AppData\Local\Nomeprogramma

Mac OS X
{Disk}:Users:{nome_utente}:Library:Caches:Nomeprogramma Client


Nel caso ci fossero problemi di accesso a queste cartelle è sempre possibile creare una cartella "ClientLocal" vicino al 4d usato come client

Su installazioni Terminal Server/Citrix purtroppo le cartelle Local e Local Settings non possono essere inserite nel profilo, quindi ogni connessione richiederebbe di scaricare sempre le informazioni dal server. Se si vuole evitare questo è possibile integrare direttamente la cartella dell'applicazione (contenente una sottocartella ClientLocal) nel profilo di roaming. Ovviamente in questo caso deve esserci un 4d usato come client per ogni utente collegato.

Le nuove versioni di 4D non duplicano piu' i subrecord all'interno del record ed il campo id_added_by_converter non e' editabile, ne avevo necessita' per cui ho fatto questa routine (spero esista un metodo piu' semplice)

Occorre preventivamente creare un set del record da duplicare ed un set del record duplicato (ricordarsi di cancellarli al termine) poi :

DuplicaSubrecords (->[TABLE];->[TABLE]Subrecord;->[TABLE_Subrecord];->[TABLE_Subrecord]id_added_by_converter)


    // DUPLICAZIONE SUBRECORDS

$p_TABLErecord:=$1 // Puntatore alla Tabella RECORD
$p_TABLEsubrecord:=$2 // Puntatore al campo SUBRECORD DEL RECORD
$p_TABLENewsubrecord:=$3 // Puntatore alla Tabella NEW SUBRECORD
$p_Id:=$4 // Puntatore al campo id_added_by_converter

$NumeroTABLE:=Table($p_TABLENewsubrecord)
USE SET("OLD") // Richiamo il record originale
QUERY($p_TABLENewsubrecord->;$p_Id->=Get subrecord key($p_TABLEsubrecord->))
$NumeroSubrecords:=Records in selection($p_TABLENewsubrecord->)
If ($NumeroSubrecords>0)
  USE SET("NEW") // Richiamo il record copia
  For ($i;1;$NumeroSubrecords)
    CREATE SUBRECORD($p_TABLEsubrecord->) // Creo l'aggancio al record
  End for
  SAVE RECORD($p_TABLErecord->)
  USE SET("OLD")
  $NumeroCampi:=Get last field number($p_TABLENewsubrecord)
  ARRAY POINTER($p_ElementoCampo;$NumeroSubrecords*$NumeroCampi)
  For ($i;1;$NumeroSubrecords)
    $P_RECORD:=($i-1)*$NumeroCampi
    For ($k;1;$NumeroCampi)
      $P_Vettore:=$P_RECORD+$k // Calcolo l'elemento del vettore
      $p_ElementoCampo{$P_Vettore}:=Get pointer("$var_"+String($k)) // Associo il puntatore
      $p_Campo:=Field($NumeroTABLE;$k) // Puntatore al campo da prelevare
      $p_ElementoCampo{$P_Vettore}->:=$p_Campo-> // Momorizzo il valore del campo sulla variabile
    End for
    NEXT RECORD($p_TABLENewsubrecord->)
  End for
  USE SET("NEW")
  QUERY($p_TABLENewsubrecord->;$p_Id->=Get subrecord key($p_TABLEsubrecord->))
  $NumeroSubrecords:=Records in selection($p_TABLENewsubrecord->)
  ON ERR CALL("ErrorIdSubrecord") // Filtra Errore su assegnazione campo id_added_by_converter (Metodo ErrorIdSubrecord VUOTO)
  For ($i;1;$NumeroSubrecords)
    $P_RECORD:=($i-1)*$NumeroCampi
    For ($k;1;$NumeroCampi)
      $P_Vettore:=$P_RECORD+$k // Calcolo l'elemento del vettore
      $p_Campo:=Field($NumeroTABLE;$k) // Puntatore al campo da assegnare
      $p_Campo->:=$p_ElementoCampo{$P_Vettore}-> // Assegno il valore dalla variabile al campo
    End for
    SAVE RECORD($p_TABLENewsubrecord->)
    NEXT RECORD($p_TABLENewsubrecord->)
  End for
  UNLOAD RECORD($p_TABLENewsubrecord->)
  ON ERR CALL("")
  SAVE RECORD($p_TABLErecord->) // Forse non serve
End if

Il file .4DLINK indica il percorso e le opzioni per aprire una struttura, sia per 4d Mono che Server.

Vengono creati automaticamente da 4D per mostrarli nei recenti, ma si possono recuperare, riutilizzare direttamente ed eventualmente modificare.

Per le versioni v11 e v12 il file si trovano nella cartella:

• Windows Vista: C:\Users\UserName\AppData\Roaming\4D\Favorites v11\
• Windows XP: C:\Documents and Settings\UserName\Application
Data\4D\Favorites v11\
• Mac OS: Users/UserName/Library/Preferences/4D/Favorites v11/


Per la versione v13:

• Windows: C:\Users\UserName\AppData\Roaming\4D\Favorites v13\

• Mac OS: /Users/UserName/Library/Application Support/4D/Favorites v13/

dove UserName è il nome dell'utente del sistema.

Quando predisponete una pagina web che deve essere visualizzata su device mobili con browser HTML5, tipo Safari Mobile su iPhone e iPad, è possibile utilizzare un metatag specifico che adatta il contenuto allo schermo.

La riga va inserita sotto il tag <head> :

<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">

Per ulteriori informazioni guarda la Safari Web Content Guide

Nella v13:

$0:=System Folder(Documents folder)


Nella v12:

// Codice di Maurizio Zanni

C_TEXT($_vt_Path)

C_LONGINT($_vl_Type)
$_vl_Type:=Desktop

//Ritorna il Path del Desktop
$_vt_Path:=System Folder($_vl_Type)

//Elimina il Separatore alla fine del Path
$i:=Length($_vt_Path)
$_vt_Path:=Substring($_vt_Path;1;$i-1)

//Ritorna il Path alla cartella Padre del Desktop
$i:=Length($_vt_Path)
While ($_vt_Path≤$i≥#Folder Separator) & ($i>0)
        $i:=$i-1
End while
$_vt_Path:=Substring($_vt_Path;1;$i-0)

//Aggiunge la Cartella Documents con il Separatore finale (Mac o Win)
$_vt_Path:=$_vt_Path+"Documents"+Folder Separator

$0:=$_vt_Path

A partire dalla versione 11 è possibile utilizzare il database in modalità Unicode.

In questa modalità, tre caratteri non possono essere memorizzati all'interno di un testo della base dati, e sono:
0
65534 (FFFE)
65535 (FFFF)

È importante sapere che, quando si indicizza un campo di tipo testo, il limite fisico di un indice B-Tree è 1024 caratteri, e dunque se si indicizzano contenuti di lunghezza maggiore la ricerca può fallire.
Nessun limite invece per quel che riguarda gli indici a keyword.

Sulla parte sinistra del nuovo Method Editor di 4D è possibile vedere, accanto al numero di linea, una piccola linea verticale colorata.

Il colore è verde per indicare che la riga non è stata modificata dall'ultimo salvataggio, giallo se la riga è stata modificata.

I lettori di barcode della Infinite Peripherals, Linea Pro per iPhone e iPod e Infinea Tab per iPad, sono quelli usati da Apple nei propri AppleStore.

Per utilizzarli con un nostro gestionale in 4d (a parte scrivere un'app nativa in IOS) potete usare una soluzione abbastanza semplice:
- da 4d pubblicate via web le pagine con le funzioni che vi servono
- scaricare l'app "Nexus Barcode" che è gia pubblicata su AppStore
- nelle impostazioni dell'app mettete l'indirizzo della vostra pagina di 4d

A questo punto quando aprite l'app si carica la pagina web del vostro gestionale:
- fate click (ops tap) sul campo da inserire
- premete il tasto del lettore di barcode che va a scrivere nel campo

Oppure:
- nella preparazione della pagina predisponete un javascript che si aspetta un solo parametro, tipo: function loadBarcode(codice) {}
- nelle impostazioni dell'app scrivete il nome della funzione: loadBarcode

In questa modalità non c'è bisogno di cliccare (tappare) il campo dove inserire il codice, basta usare il lettore del barcode; a parte la comodità di un passaggio in meno, l'altro vantaggio è che non serve far apparire la tastiera che sullo schermo dell'iPod significa guadagnare un bel po' di spazio

Per l'hardware dei lettori ci si può rivolgere al distributore italiano dei lettori barcode per iPhone, iPod, iPad Cidroid, divisione della Nexus.

Una delle prime FAQ pubblicate su Sviluppo4D riguardava la limitazione del numero di caratteri inseribili in un campo Alpha.

Eccone una versione aggiornata:
Case of
      : (Form event=On After Edit)
      If (Length(Get edited text)>=vLength)
           $textvariable:=Substring(Get edited text;1;vLength)
      End if
End case

A vLength può essere sostituita la lunghezza del campo, nei casi in cui è possibile.

A $textvariable potrebbe essere sostituito Self->, ma in questo caso il metodo non funziona ad esempio sugli elementi degli array di una listbox.

Utilizzando il metodo di Keisuke Miyako per l'esecuzione di un VB script, vediamo un esempio di conversione di un file utilizzando MS Word.

Ecco il testo di uno script che apre un file e lo salva in formato solo testo:


Set objWord = CreateObject("Word.Application")
Set objDoc = objWord.Documents.Open("C:\codici.doc")
Const wdFormatText = 2
objDoc.SaveAs "C:\codici.txt", wdFormatText
objWord.Quit




Ecco il metodo (lievemente modificato) di Keisuke Miyako:

C_TEXT($1;$0)
C_BLOB($2)

C_LONGINT($platform_l)
PLATFORM PROPERTIES($platform_l)

If ($platform_l=Windows)

$script_folder_path_t:=Get 4D folder(Current Resources folder)+"vbs\\"
$script_file_path_t:=$script_folder_path_t+Replace string($1;"/";"\\";*)

      If (Test path name($script_file_path_t)=Is a document)

           SET ENVIRONMENT VARIABLE("_4D_OPTION_HIDE_CONSOLE";"true")
           C_BLOB($standard_input_x;$standard_output_x;$standard_error_x)

           If (Count parameters=2)
           $standard_input_x:=$2
           //patch to counter data loss caused by CRLF's in input stream
           SET BLOB SIZE($standard_input_x;BLOB size($standard_input_x)+8166;0)
           End if

           LAUNCH EXTERNAL PROCESS("cscript //Nologo //U \""+$script_file_path_t+"\"";$standard_input_x;$standard_output_x;$standard_error_x)
           $standard_output_t:=Convert to text($standard_output_x;"UTF-16LE")

           If (BLOB size($standard_error_x)#0) & (BLOB size($standard_output_x)=0)
           $0:=Convert to text($standard_error_x;"UTF-16LE")
           Else
           $0:=$standard_output_t
           End if

      End if

End if

Alcune istruzioni veloci su come intervenire nel caso in cui 4d si chiude all'avvio.

Se si riesce ad entrare come Designer basterà verificare la procedura di startuo legata allo specifico user.

Se non si riesce proprio ad entrare, provare una delle seguenti opzioni (una alla volta!)

1. Sei sicuro di essere entrato come Designer?
Se per caso hai impostato un utente di default non fa andare in ambiente Designer e quindi potrebbe non intercettare eventuali errori.
Per verificare tieni premuto il maiuscolo al lancio del programma, così ti appare la lista degli utenti.

2. provare a togliere temporaneamente i plugin

3. cancellare le preferenze di 4d (attento a tenere il file delle licenze)

4. fare una verifica della struttura con 4d tools

5. recuperare l'ultima copia della struttura funzionante

5. provare a verificare la struttura con un'utilitty tipo SanityCheck della Committedsoftware, che funziona fino alla versione 2004.5
http://www.committedsoftware.com/sanitycheck.html

Ecco i risultati dei primi test con le versioni di 4d v12.4 e v13.1 su Mountain Lion.

Restano aperti solo quattro problemi, che saranno sicuramente fissati nelle prossime versioni (subito nelle prossime versioni Hotfix per i Partner):

2 problemi importanti riguardano un crash dopo:
- il cambio di stampante da codice
- la stampa dagli editor di Etcihette o dal Quick Report

2 solo cosmetici riguardano:
- il comando OBJECT SET ENABLE non mette in grigio il testo disabilitato
- il colore della selezione di record nelle maschere di tipo Lista

Inoltre 4d sas dovrà gestire in qualche modo la nuova gestione di Gatekeeper, per certificare le prossime versioni di 4d con Apple.

Da segnalare un problema con il web server Apache integrato in OS X: se la condivisione web era attiva prima di aggiornare a Mountain Lion, 4d non pèotrà accedere alla porta 80 con il suo Web server.
Purtroppo in Mountain Lion non c'è più la preferenza che stoppa Apache, per cui bisognerà interromperlo con il comando da terminale:
sudo apachectl stop

cfr http://www.4d.com/blog/information-4d-mountain-lion.html

Il formato XML plist è lo standard con cui sono scritte ad esempio le preferenze dei vari programmi su Mac OS X.

Il formato è letto nativamente dalle applicazioni scritte in XCode, come ad esempio programmi per iPhone e iPad.

L'esempio successivo mostra come creare una plist per ad esempio inviare dei dati strutturati ad un applicativo su iOS in modo semplice e veloce: infatti un xml generico andrebbe ogni volta interpretato, mentre la plist può essere letta direttamente come un NSDictionary.

    ` ----------------------------------------------------
    ` User name (OS): Umberto Migliore
    ` Date and time: 08-02-11, 12:22:51
    ` ----------------------------------------------------
    ` Method: nx_crea_plist
    ` Description:
    `mostra come creare un documento plist:
    `
    `<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
    `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    `<plist version="1.0">
    ` <dict>
    ` <key>Author</key>
    ` <string>William Shakespeare</string>
    ` <key>Title</key>
    ` <string>Macbeth</string>
    ` <key>Lines</key>
    ` <array>
    ` <string>It is a tale told by an idiot,</string>
    ` <string>Full of sound and fury, signifying nothing.</string>
    ` </array>
    ` <key>Birthdate</key>
    ` <integer>1564</integer>
    ` </dict>
    `</plist>
    `
    ` Parameters
    ` ----------------------------------------------------
C_TEXT($autore;$titolo)
C_LONGINT($annonascita)
ARRAY TEXT($citazione;0)

    `=== preparo i dati
$autore:="William Shakespeare"
$titolo:="Macbeth"
$annonascita:=1564
APPEND TO ARRAY($citazione;"It is a tale told by an idiot,")
APPEND TO ARRAY($citazione;"Full of sound and fury, signifying nothing.")

    `=== creo la plist
$xml_ref:=DOM Create XML Ref("plist";"";"version";"1.0")

    `=== dict principale che contiene tutto
$dict:=DOM Create XML element($xml_ref;"dict")

$key:=DOM Create XML element($dict;"key")
DOM SET XML ELEMENT VALUE($key;"Author")
$value:=DOM Create XML element($dict;"string")
DOM SET XML ELEMENT VALUE($value;$autore)

$key:=DOM Create XML element($dict;"key")
DOM SET XML ELEMENT VALUE($key;"Title")
$value:=DOM Create XML element($dict;"string")
DOM SET XML ELEMENT VALUE($value;$titolo)

$key:=DOM Create XML element($dict;"key")
DOM SET XML ELEMENT VALUE($key;"Lines")
$array:=DOM Create XML element($dict;"array")
For ($riga;1;Size of array($citazione))
  $value:=DOM Create XML element($array;"string")
  DOM SET XML ELEMENT VALUE($value;$citazione{$riga})
End for

$key:=DOM Create XML element($dict;"key")
DOM SET XML ELEMENT VALUE($key;"Birthdate")
$value:=DOM Create XML element($dict;"integer")
DOM SET XML ELEMENT VALUE($value;$annonascita)

    `=== chiude l'xml, aggiunge lo header e ritorna un testo
DOM EXPORT TO VAR($xml_ref;$testo)
DOM CLOSE XML($xml_ref)
$header:="<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
$testo:=Insert string($testo;$header;Position("<plist";$testo))

ALERT($testo)  ` $0:=$testo

Quando si crea un XML, i comandi di 4d lo creano con tutta l'indentazione necessaria ad una più facile lettura.

Però se l'xml è utilizzato per comunicazioni via wan (server to server, mobile to server, etc) in produzione è meglio risparmiare in dimensioni dei messaggi, ad esempio togliendo l'indentazione: su file complessi con molti livelli di indentazione il risparmio può essere notevole.

Fino alla v11 si usava il secondo parametro del comando
DOM SET XML OPTION

Dalla v12 il comando è stato rinominato
DOM SET XML OPTION -> DOM SET XML DECLARATION

e invece per le opzioni più generiche si usa il comando più specifico
XML SET OPTION

Questo comando ha diverse opzioni, nel caso specifico la sintassi è:

DOM SET XML OPTION($idRef; XML Indentation; XML No indentation)

Questo codice è un esempio di utilizzo del componente incluso in 4d per gestire i comandi SVG; lo scopo del metodo è di ruotare di 90 gradi un'immagine, ad esempio per raddrizzare una foto.

    // ----------------------------------------------------
    // User name (OS): Umberto Migliore
    // Date and time: 14-02-11, 11:41:14
    // ----------------------------------------------------
    // Method: nx_svgRuotaQuartoDestra
    // Description
    // Ruota un immagine di un quarto di giro a destra
    //
    // Parameters
    // ----------------------------------------------------

C_PICTURE($immagine;$1;$0)
$immagine:=$1
PICTURE PROPERTIES($immagine;$larga;$alta)
$maggiore:=Choose($larga>$alta;$larga;$alta)
$svg:=SVG_New ($alta;$larga)
$img:=SVG_New_embedded_image ($svg;$immagine;0;0)
SVG_SET_TRANSFORM_ROTATE ($svg;90;$maggiore/2;$maggiore/2)
If ($larga>$alta)
  SVG_SET_TRANSFORM_TRANSLATE ($svg;0;$larga-$alta)
End if
$immagine:=SVG_Export_to_picture ($svg;0)
SVG_CLEAR ($svg)
$0:=$immagine

I servizi webservice possono richiedere l'autenticazione in diversi modi:

1. lo standard http BASIC
-> si può usare il comando WEB SERVICE AUTHENTICATE ("nome", "password"; 1)

2. lo standard http DIGEST
-> si può usare il comando WEB SERVICE AUTHENTICATE ("nome", "password"; 2)

3. uno dei due standard http, ma con un proxy http intermedio:

-> si usa il doppio comando
WEB SERVICE AUTHENTICATE ("nome", "password", 0) `può essere BASIC o DIGEST
WEB SERVICE AUTHENTICATE ("nome2", "password2", *) `dati di accesso al proxy

4. può essere del tipo SOAP HEADER, cioè inclusa nel corpo della SOAP

$xml:=DOM Create XML Ref("auth")
$utente:=DOM Create XML element($xml;"username")
DOM SET XML ELEMENT VALUE($utente;"nome")
$password:=DOM Create XML element($xml;"password")
DOM SET XML ELEMENT VALUE($password;"password")
SET WEB SERVICE OPTION(Web Service SOAP Header,$xml)
DOM CLOSE XML($xml)

Sono eventualmente da verificare che i nodi siano "username" e "password"

Come tutti sappiamo, la funzione Position() di 4D restituisce la posizione del primo carattere trovato, ma partendo da sinistra.

In giro ho trovato questo ciclo per trovare la posizione della prima occorrenza di una stringa inclusa in un'altra a partire dalla destra della stringa.
Un po come InStrRev di VB.

C_INTEGER($Pos;$start;$lengthfound;$Result)
C_TEXT($Temp)
  // Ricava la path della cartella preferenze
// Replace string(... Aggiunge un Folder separator alla stringa ricavata:
// Se Folder separator esiste, sostituisce i due Folder separator risultanti con una stringa vuota
// Se Folder separator esiste, non fa' nulla
// In ogni caso la stringa ricavata non terminerà con Folder separator !

$Temp:=Replace string(Get 4D folder(Active 4D Folder)+Folder separator;Folder separator+Folder separator;"")
$Pos:=0
$start:=1
Repeat
  $Result:=Position(Folder separator;$Temp;$start;$lengthfound)
  If ($Result#0)
    $Pos:=$Result
  End if
  $start:=$start+$lengthfound
Until ($Result=0)
<>g_PathPreferences:=Substring($Temp;1;Length(Substring($Temp;1;$Pos)))+Folder separator

Sicuramente funzionante ma, a mio avviso, un po' troppo 'contorta'.
Si puo' semplificare cosi:
    
C_TEXT($Temp)
C_INTEGER($Conta)
    // Ricava la path della cartella preferenze
$Temp:=Replace string(Get 4D folder(Active 4D Folder)+Folder separator;Folder separator+Folder separator;"")
For ($Conta;Length($Temp);1;-1)
  If (Substring($Temp;$Conta;1)=Folder separator)
    $Temp:=Substring($Temp;1;$Conta)
    $Conta:=1
  End if
End for
<>g_PathPreferences:=$Temp+Folder separator

Oltre ad avere un codice piu' leggibile, abbiamo risparmiato tre righe di procedura (a parte le note) e dichiarato
due variabili contro cinque della procedura precedente.

Non è il massimo ...ma con la crisi che incombe, bisogna centellinare tutto.

Il testo in 4d era in Mac ASCII fino alla versione 2004, dalla v11 è in UTF-16 (a meno che non abbiate lasciato la compatibilità Ascii del db)

Quando si esporta un file in Unicode è necessario normalmente indicare in che formato sono i caratteri che occupano 2 byte (big-endian o little-endian) con un prefisso chiamato un BOM (Byte Order Mark). In realtà in UTF-8 si tende ad esportare i caratteri in byte singoli quindi in linea di massima non ci sono problemi di ordinamento dei byte, e non servirebbe.

Però alcune applicazioni se lo aspettano comunque, quindi a volte è necessario aggiungerlo, come ad esempio con questa procedura:

C_TEXT($1;$testo_t)
C_BLOB($blob_b;$bom_b)

$testo_t:=$1

SET BLOB SIZE($bom_b;3)
$bom_b{0}:=239 ` EF
$bom_b{1}:=187 ` BB
$bom_b{2}:=191 ` BF

CONVERT FROM TEXT($testo_t;"UTF-8";$blob_b)

$doc_h:=Create document("")
If (OK=1)
  SEND PACKET($doc_h;$bom_b)
  SEND PACKET($doc_h;$blob_b)
  CLOSE DOCUMENT($doc_h)
End if

I comandi Average, Max, Min, Std deviation, Sum, Sum squares e Variance che storicamente si usavano solo nella stampa dei rapporti (dopo un comando Accumulate) adesso funzionano anche sulla selezione corrente o su un array.

L'effetto sulla ottimizzazione del codice è immediato:
dove prima ad esempio per avere la somma di un array occorreva ciclare sui suoi elementi adesso basta scrivere $totale:=Sum($array).

Uso questo metodo nell'oggetto Popup cmb_Cliente che risolve velocemente il problema del valore di default quando un database è completamente vuoto.

Case of
  : (Form event=On Load)
  ARRAY LONGINT(cmb_CodCliente;0)
  ARRAY TEXT(cmb_Cliente;0)

  ALL RECORDS([Clienti])
  SELECTION TO ARRAY([Clienti]Progressivo;cmb_CodCliente; [Clienti]Rag_Sociale;cmb_Cliente)
  If (Size of array(cmb_CodCliente)>0)
    If (Is new record([Stabilimenti])) //nuova scheda
      cmb_Cliente:=1 //mostra un valore di default
      cmb_CodCliente:=cmb_Cliente
    Else //se ci sono record, cerca il codice nel vettore cmb_CodCliente
      // Se Find in array ritorna -1 verrà generato un errore
      // Usando Abs(Find in array..... restituira -1 (quindi 1)
      cmb_CodCliente:=Abs(Find in array(cmb_CodCliente;[Stabilimenti]Cod_Cliente))
      cmb_Cliente:=cmb_CodCliente
    End if
  End if
  : (Form event=On Clicked)
  If (cmb_Cliente#0)
    cmb_CodCliente:=cmb_Cliente
    [Stabilimenti]Cod_Cliente:=cmb_CodCliente{cmb_CodCliente}
  End if
  : (Form event=On Unload)
    CLEAR VARIABLE(cmb_CodCliente)
    CLEAR VARIABLE(cmb_Cliente)
End case

Il formato XML di data e ora è il seguente AAAA-MM-GGTHH:MM:SS.

Il vantaggio di questa stringa è che è ordinabile, contiene la coppia dei dati e quindi è più leggibile del timestamp (che rimane però più efficiente e consuma meno spazio su disco e in memoria come indice).

Ecco alcuni trucchi per convertire una data in questo formato e viceversa (non documentati, mi sembra) in 4d 2004.3:

Date("2006-01-24T00:00:00") -> ritorna effettivamente la data 24 gen 2006: Importante funziona solo se la stringa è lunga 19 caratteri e la data è seguita dal separatore "T".

String(current date;8) -> ritorna la data nel formato XML completa di separatore = "2006-01-24T00:00:00"

Per avere data e ora si può usare questa semplice riga:

Replace string(String(Current date;8);"00:00:00";String(Current time;1))

Il seguente metodo prende come parametri il puntatore ad una listbox, il separatore fra le colonne e quello fra le righe per inserire negli appunti il contenuto della listbox stessa.


C_POINTER($1;$lbPointer_p)
C_TEXT($2;$columnSeparator_t)
C_TEXT($3;$rowSeparator_t)

C_LONGINT($i;$numRows_l)
C_LONGINT($j;$numCols_l)
C_TEXT($theData_t)

ARRAY TEXT($colNames_at;0)
ARRAY TEXT($headerNames_at;0)
ARRAY POINTER($colVars_ap;0)
ARRAY POINTER($headerVars_ap;0)
ARRAY BOOLEAN($colsVisible_ab;0)
ARRAY POINTER($styles_ap;0)

$lbPointer_p:=$1

If (Count parameters>1)
      $columnSeparator_t:=$2
        $rowSeparator_t:=$3
Else
        $columnSeparator_t:=Char(Tab)
        $rowSeparator_t:=Char(Carriage return)
End if

LISTBOX GET ARRAYS($lbPointer_p->;$colNames_at;$headerNames_at;$colVars_ap;$headerVars_ap;$colsVisible_ab;$styles_ap)

$numRows_l:=Size of array($colVars_ap{1}->)
$numCols_l:=Size of array($colNames_at)

For ($i;1;$numRows_l)

      For ($j;1;$numCols_l)
           If ($colsVisible_ab{$j}=True)
           If ($j#1)
           $theData_t:=$theData_t+$columnSeparator_t
           End if
           $theData_t:=$theData_t+String($colVars_ap{$j}->{$i})
           End if
      End for

      If ($i<$numRows_l)
           $theData_t:=$theData_t+$rowSeparator_t
      End if

End for

SET TEXT TO PASTEBOARD($theData_t)


-----------

Da notare come:
- il comando String può ricevere come parametro anche una stringa;
- per testi grandi il testo potrebbe essere prima inserito il un BLOB.

Col seguente metodo l'array URL_a viene popolato con gli URL che contiene myString:

ARRAY LONGINT(posFound_a;0)
ARRAY LONGINT(lengthFound_a;0)
ARRAY TEXT(URL_a;0)
C_LONGINT($start)
C_TEXT($mySubstring;myString;$1)
C_TEXT(stringNew; pattern)
C_BOOLEAN($found)

myString:=$1
$start:=1
$found:=False
pattern:="(http|https|ftp)" ` http o https, o ftp.
pattern:=pattern + "\\://" ` ://
pattern:=pattern + "[a-zA-Z0-9\\-\\.]+" `la prima parte del dominio
pattern:=pattern + "\\.[a-zA-Z]{2,4}" `la seconda parte
pattern:=pattern + "(:[a-zA-Z0-9]*)?/?" `la porta e lo slash
pattern:=pattern + "([a-zA-Z0-9\\-\\._?\\,'/\\+%\\$#\\=~\\:\\&])*" `Caratteri riservati
pattern:=pattern + "[^\\.\\,\\)\\(\\s\\']" `Caratteri da escludere
Repeat
  $found:=Match regex(pattern;myString;$start;posFound_a;lengthFound_a)
  stringNew:=Substring(myString;posFound_a{0};lengthFound_a{0})
  If ($found)
    APPEND TO ARRAY(URL_a;stringNew)
  End if
  $start:=posFound_a{0}+lengthFound_a{0}
Until (Not($found))

Utilizzando i comandi SQL è possibile interrogare la tabella di sistema _USER_CONSTRAINTS per ottenere in una listbox chiamata ListBox_Relations l'elenco di tutte le relazioni presenti in un database o loro proprietà.

-----
Un primo esempio

Begin SQL
  SELECT * FROM _USER_CONSTRAINTS
  WHERE CONSTRAINT_TYPE = 'P'
  INTO LISTBOX :miaListBox;
End SQL

per ottenere l'elenco di tutte le chiavi primarie utilizzate.
-----
Un secondo esempio

Begin SQL
  SELECT * FROM _USER_CONSTRAINTS
  WHERE CONSTRAINT_TYPE = 'R'
  INTO LISTBOX :miaListBox;
End SQL

per l'elenco delle chiavi esterne.

-----
Per l'elenco completo


Begin SQL
  SELECT * FROM _USER_CONSTRAINTS
  INTO LISTBOX :miaListBox;
End SQL

Il comando Replicate eseguito su un 4d (Locale) permette di leggere da un 4d (Remoto) gli ultimi record modificati/cancellati dopo l'ultima lettura, per avere la "replica" aggiornata di alcune tabelle.

La sintassi minima è la seguente:

REPLICATE campoid, campo1, campo2, campo3
FROM tabellaRemota
FOR REMOTE STAMP :vRemote_Stamp
REMOTE OVER LOCAL
LATEST REMOTE STAMP :vRiceviCorrenteUltimoStam
INTO localTable(campoid, campo1, campo2, campo3);

Da notare che in vRiceviCorrenteUltimoStam arriva l'ultimo Stamp corrente da conservare per usarlo nella prossima volta che si fa la stessa chiamata.

Questa di seguito è la versione completa dei parametri opzionali, con una clausola WHERE per selezionare i record da tagliare, con la LIMIT e la conseguente OFFSET per tagliare l'esportazione in più parti

REPLICATE campoid, campo1, campo2, campo3
FROM tabellaRemota
WHERE tabellaRemota.campox=:vCondizione
LIMIT :vLimit_Value
OFFSET :vOffset_Value
FOR REMOTE STAMP :vRemote_Stamp,
LOCAL STAMP :vLocal_Stamp
REMOTE OVER LOCAL /*oppure LOCAL OVER REMOTE*/
LATEST REMOTE STAMP :vRiceviCorrenteUltimoStam,
LATEST LOCAL STAMP :vLatest_Local_Stamp
INTO localTable(campoid, campo1, campo2, campo3);


Da notare che posso leggere i dati senza doverli appoggiare su una tabella, ma solo in array.

REPLICATE campoid, field1, field2, field3
FROM remoteTable
FOR REMOTE STAMP :vRemote_Stamp
REMOTE OVER LOCAL
LATEST REMOTE STAMP :vRiceviCorrenteUltimoStam
INTO :aID, :aCampo1, :aCampo2, :aCampo3;


REPLICATE campoid, campo1, campo2, campo3
FROM tabellaRemota
WHERE tabellaRemota.campox=:vCondizione
LIMIT :vLimit_Value
OFFSET :vOffset_Value
FOR REMOTE STAMP :vRemote_Stamp,
LOCAL STAMP :vLocal_Stamp
REMOTE OVER LOCAL /*oppure LOCAL OVER REMOTE*/
LATEST REMOTE STAMP :vRiceviCorrenteUltimoStam,
LATEST LOCAL STAMP :vLatest_Local_Stamp
INTO :aID, :aCampo1, :aCampo2, :aCampo3;

Il comando Equal pictures confronta precisamente due immagini per dimensione e contenuto.

Il comando accetta 3 parametri: i primi 2 sono le immagini da confrontare, nel terzo si troverà un'immagine maschera con a nero i pixel identici.

Ritorna False se le dimensioni non sono uguali.

Se le dimensioni sono uguali il confronto è a livello di pixel, e nella maschera viene 'acceso' in bianco il pixel che segna la differenza.
        
Se non ci sono differenze neanche a livello di pixel il comando ritorna True.

Una inner join crea una griglia di dati combinando i valori delle due tabelle di partenza (A and B) basandosi su una certa regola di confronto: la query compara ogni riga della tabella A con ciascuna riga della tabella B cercando di soddisfare la regola di confronto definita.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    INNER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
Rossi	Nexus
Verdi	Acme

Una right outer join (o right join) semplicemente ricalca il funzionamento della left outer join, ma invertendo l'ordine delle tabelle interessate.
Il risultato di una query right outer join per le tabelle A e B contiene sempre tutti i record della tabella di destra ("right") B, mentre vengono estratti dalla tabella di sinistra ("left") A solamente le righe che trovano corrispondenza nella regola di confronto della join. Questo significa che se la clausola ON trova 0 (zero) righe in A, la join mostrerà una riga risultante con valore NULL in tutte le colonne corrispondenti al risultato per le colonne di A.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

  Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    RIGHT OUTER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
NULL	NewCo
Rossi	Nexus
Verdi	Acme

Il risultato di una query left outer join (o semplicemente left join) per le tabelle A e B contiene sempre tutti i record della tabella di sinistra ("left") A, mentre vengono estratti dalla tabella di destra ("right") B solamente le righe che trovano corrispondenza nella regola di confronto della join. Questo significa che se la clausola ON trova 0 (zero) righe in B, la join mostrerà una riga risultante con valore NULL in tutte le colonne corrispondenti al risultato per le colonne di B.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

  Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    LEFT OUTER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
Bianchi	NULL
Rossi	Nexus
Verdi	Acme

Una full outer join combina i risultati delle due tabelle A e B tenendo conto di tutte le righe delle tabelle, anche di quelle che non hanno corrispondenza tra di loro.
Il risultato di una query full outer join per le tabelle A e B contiene sempre tutti i record della tabella di sinistra ("left") A, estraendo dalla tabella di destra ("right") B solamente le righe che trovano corrispondenza nella regola di confronto della join; inoltre verranno estratti tutti i record della tabella di sinistra ("left") A che non trovano corrispondenza nella tabella di destra ("right") B impostando a NULL i valori di tutte le colonne della tabella B e tutti i record della tabella di destra ("right") B che non trovano corrispondenza nella tabella di sinistra ("left") A impostando a NULL i valori di tutte le colonne della tabella A.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    FULL OUTER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
NULL	NewCo
Bianchi	NULL
Rossi	Nexus
Verdi	Acme

Una cross join fornisce le basi attraverso cui tutti i tipi di inner join operano.
Il risultato di una cross join è il prodotto cartesiano di tutte le righe delle tabelle che concorrono alla query di join. E' come dire che stiamo facendo una inner join senza impostare la regola di confronto o in cui la regola di confronto ritorna sempre vero.


Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    CROSS JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
Bianchi	Nexus
Bianchi	Acme
Bianchi	NewCo
Rossi	Nexus
Rossi	Acme
Rossi	NewCo
Verdi	Nexus
Verdi	Acme
Verdi	NewCo

Su Windows le librerie di Quicktime potrebbero non essere installate e alcune immagini registrate con un 4d precedente alla v11 potrebbero non vedersi:
  appare in questo caso un riquadro bianco con la scritta del tipo "Quicktime is required"

ARRAY TEXT($identificativi_at;0)
ARRAY TEXT($nomi_at;0)
PICTURE CODEC LIST($identificativi_at;$nomi_at)
If (Find in array($identificativi_at;".qtif")<0) // Tipo immagine QuickTime
  ALERT("QuickTime non è installato.")
End if

A partire dalla v11 le immagini in 4D non sono più salvate come PICT, ma nel loro formato originale.
Però se abbiamo convertito un db ci potrebbero essere delle immagini che richiedono Quicktime per essere viste su Windows.

Per eliminare la necessità di questa installazione è possibile usare il comando CONVERT PICTURE, come ad esempio:

ALL RECORDS([MieImmagini])
While (Not(End selection([MieImmagini])))
  CONVERT PICTURE([MieImmagini]Immagine;".jpg")
  SAVE RECORD([MieImmagini])
  NEXT RECORD([MieImmagini])
End while

Dalla v12 questo comando permette anche la compressione del JPEG con questa sintassi:
CONVERT PICTURE([MieImmagini]Immagine;".jpg"; 0.6)

NOTA: Ovviamente per essere eseguita questa procedura richiede Quicktime, la volta in cui viene eseguita.

cfr Verifica da codice se Quicktime è installato

Le alternative per utilizzare l'ipad o l'iphone collegandolo a 4d sono, partendo dalle più facili:

1. utilizzare un app tipo iSort
pro: l'app costa veramente poco ed è subito disponibile, su 4d serve la licenza web
contro: le possibilità di personalizzazione sono poche, e non si può programmare lato ipad (Apple vieta esecuzione di codice nelle app)

2. preparare delle pagine web servite da 4d, semplici senza usare ajax o framework
pro: sviluppo semplice, il safari di iPad è un browser vero e completo, compatibile con html5, css e javascript
contro: funziona bene se c'è sempre copertura, ad esempio usandolo in area coperta da wifi

3. preparare delle pagine web servite da 4d, utilizzando ajax o framework
pro: puoi usare degli oggetti più completi, come griglie di dati, se perdi il collegamento potresti usare i dati offline
contro: comunque serve la connessione internet attiva, una parte di programmazione si sposta su javascript

4. scrivere un programma in objective c
pro: puoi scriverti un'applicazione completa registrando in locale i dati sui cui lavorare, scaricando e inviando solo ogni tanto gli aggiornamenti
Il collegamento a 4d si può fare :
- via web utilizzando l'url speciale 4DSYNC che sfrutta la funzionalità di sincronizzazione inclusa in v12 (cfr iPhone, iPad, Android e l'url 4DSYNC
- via webservice o semplice chiamata GET (/4daction/metodo/parametro..); 4d può essere sia server che monoutenza con licenza web
- via file: l'app può scaricare un file postato in una directory web con autenticazione, può inviare i dati in formato POST; si perde il realtime, ma non serve licenza web

contro: è più lungo scrivere in obiettive e si devono valutare bene le modalità di distribuzione, che riporto:
- app ad hoc: si installa su un massimo di 100 ipad/iphone per sviluppatore (l'elenco si può resettare solo 1 volta all'anno)
- app enterprise: l'azienda cliente si registra come Enterprise a 299$ anno può installare su quanti ipad vuole
- app su appstore: i limiti sono quelli delle regole di approvazione Apple, i tempi di rilascio sono di 5-10 giorni per ogni aggiornamento

Questo codice è un esempio di SQL con cui è possibile modificare un valore in diversi record con un unico comando.

Presupponendo che abbiamo una Tabella in cui i record hanno un campo Codice e un campo Nome, il comando nel formato Begin SQL sarà così:

Begin SQL
  update [Tabella]
  set Nome = CASE Codice
  when 1 then 'NomeUno'
  when 2 then 'NomeDue'
  when 3 then 'NomeTre'
  end
  where codice in (1,2,3)
end sql

In pratica:
1) il WHERE campo IN (n,n,..) mi seleziona i record il cui Codice è nella lista
2) il CASE ritorna il valore desiderato al variare del campo Codice

Lo "UserSet" è lo speciale set che contiene i record selezionati dall'utente nel form di output.

Quando serve è comunque possibile popolarlo "manualmente": se abbiamo un array contenente dei record number, è possibile scrivere:

CREATE SET FROM ARRAY([Table];$arrRecNum;"UserSet")

per simulare la selezione dei record "manuale" da parte dell'utente.

Come si può facilmente vedere, dalla 4D v12 è stato radicalmente modificato il method editor. Una delle modifche più utili riguarda la possibilità di poter mandare a capo le righe in modo da avere un'istruzione più facilmente leggibile (si pensi, ad esempio, alle righe infinite di estesi SELECTION TO ARRAY).

Adesso basta far finire una riga col carattere "\" e ill testo della riga successiva verrà considerato come prosecuzione dell'attuale.

Utilizzando la nuova opzione "Execute in server" per i metodi, bisogna ricordare che:
- il processo sul server non è creato al momento, ma usa il processo "gemello" che gira sul server
- il metodo su server considera i record bloccati e le transazioni, ma non tiene conto dei valori delle variabili sul client e non mantiene la selezione corrente.
- le variabili processo del metodo sul server persistono (con valore) anche dopo la conclusione del processo stesso sul server
- se passi un puntatore ad una variabile o un array il valore puntato è inviato al server e ritornato al client se modificato

Sul server non possono essere eseguiti alcuni comandi: se provi a farlo apparirà una finestra di dialogo. Alcuni comandi non funzionanti nei metodi sono:

Comandi correlati all'interfaccia
ADD RECORD
ADD SUBRECORD
DISPLAY SELECTION
FILTER EVENT
GRAPH TABLE
Level
ON EVENT CALL
MODIFY RECORD
MODIFY SELECTION
MODIFY SUBRECORD
Open external window
QUERY BY EXAMPLE
QR REPORT

Comandi di struttura
CHANGE LICENSES
CREATE DATA FILE
EDIT ACCESS
OPEN DATA FILE
CALL PROCESS

Comandi sulle risorse
SET PICTURE TO LIBRARY
REMOVE PICTURE FROM LIBRARY
SET PICTURE TO LIBRARY

Comandi per la gestione dei menu
APPEND MENU ITEM
Count menu items
Count menus
DELETE MENU ITEM
DISABLE MENU ITEM
ENABLE MENU ITEM
Get menu item
Get menu item key
Get menu item mark
Get menu item style
Get menu title
INSERT MENU ITEM
Menu selected
SET MENU ITEM
SET MENU ITEM SHORTCUT
SET MENU ITEM MARK
SET MENU ITEM STYLE
SHOW MENU BAR

Comandi per la stampa
ACCUMULATE
BREAK LEVEL
PAGE BREAK
PAGE SETUP
PRINT SETTINGS
Printing page
Subtotal

Dovendo scaricare da Gmail gli aggiornamenti del gruppo Sviluppo4D su Facebook inviati da Umberto in occasione del summit di Boston, ecco il codice utilizzato all'uopo.

C_TEXT($msgText)
READ WRITE([Posta])
$error:=0
$sslPOPPort:=995
$Errore_l:=IT_SetPort (13;$sslPOPPort) //12 is for 'SMTP with SSL'
$error:=IMAP_Login ("pop.gmail.com";"indirizzo@gmail.com";"password";$imapID;1)
$error:=IMAP_SetCurrentMB ($imapID; "4D Summit 2011"; $msgNber; $newMsgNber; $customFlags; $permanentFlags; $mbUID)
For ($i;1;$msgNber)
      CREATE RECORD([Posta])
      msgDataItem:="INTERNALDATE"
      $Err:=IMAP_MsgFetch ($imapID;$i;msgDataItem;$text)
      $position:=Position(" ";$text)
      $text:=Delete string($text;1;$position)
      $error:=IMAP_GetMessage ($imapID;$i;0;31000;2;$msgText;1)

      $datrovare:="nel gruppo Sviluppo4D"
      $position:=Position($datrovare;$msgText)
      $msgText:=Delete string($msgText;1;$position+Length($datrovare)+2)

      $datrovare:="Per commentare"
      $position:=Position($datrovare;$msgText)
      $msgText:=Delete string($msgText;$position-2;Length($msgText))
      [Posta]msg_body:=$msgText
      [Posta]msg_ID:=$i
      SAVE RECORD([Posta])
      UNLOAD RECORD([Posta])

End for


$error:=IMAP_Logout($imapID)

Nella v12 è possibile usare database esterni: ecco un esempio veloce per trasferire i dati da una tabella locale nell'equivalente tabella sul db esterno.


ALL RECORDS([Tabella])
SQL EXPORT SELECTION([Tabella];$percorsoAppoggio)

Begin SQL
      USE DATABASE DATAFILE :$percorsoDB;
End SQL

$importa:=$percorsoAppoggio+Folder separator+
importa:=importa+"SQLExport"+Folder separator
importa:=importa+"Export.sql"

SQL EXECUTE SCRIPT($importa;SQL On error abort)

Begin SQL
      USE DATABASE SQL_INTERNAL;
End SQL

Sin dalla versione v11, anche la struttura di 4d è un database e gli aggiornamenti fatti in fase di sviluppo seguono le stesse regole delle modifiche ai dati.

Se 4d si chiude inaspettatamente si potrebbero perdere le ultime modifiche fatti (modifiche al codice o ai form, ad esempio).

Per forzare il salvataggio si può:
- compilare
- passare da Design mode ad Application mode (e viceversa)
- eseguire il comando FLUSH BUFFERS

Ecco di seguito il codice di un pulsante che permette di stampare il contenuto di una Rich Text Area memorizzato nel campo [Tabella]MioTesto:

Case of
      : (Form event=On Clicked)

      PRINT SETTINGS

      If (ok=1)
           OPEN PRINTING JOB

           If (ok=1)
           OPEN PRINTING FORM("Form1")
           vStampa:=OBJECT Get styled text([Tabella]MioTesto)
           $complete_b:=Print object(*;"vStampa")
           CLOSE PRINTING JOB
           End if
      End if
End case

Con la versione 12 è possibile copiare le definizioni dei campi da una tabella ad un'altra.

Nella maschera "Structure" prendi la tabella di partenza, selezioni i campi che ti servono nella nuova tabella.
Effettui il copia (mela+c o ctrl+c).

Selezioni la tabella di destinazione ed effettui incolla (mela+v o ctrl+v).

4D ti genera nella nuova tabella i campo con nomi e proprietà identiche ai campi selezionati nella tabella di partenza.

Per il collegamento da un Client a 4D Server le porte TCP di default sono:

19813 - Application server
19814 - DB4D server
19812 - SQL server

Sulla porta DB4D sono veicolate tutte le chiamate al database, un socket per ogni processo divise poi sul server in thread differenti.

Dalla versione 12.2 è disponibile il nuovo comando FORM SCREENSHOT che accetta due sintassi:

FORM SCREENSHOT ( formPict )
Crea una schermata del form corrente al momento

FORM SCREENSHOT ( {aTable ;} formName ; formPict {; pageNum} )
Crea una schermata di un form del database come vista nel form editor

La variabile che indica la posizione attuale in un array è automaticamente dichiarata come Integer, tipo che ha il limite di 32767.
Questo significa che il codice:

ARRAY TEXT($largeArray_at;33000)
For ($i;1;33000)
        $largeArray_at{$i}:=String($i)
End for

$largeArray_at:=32768
$element:=$largeArray_at{$largeArray_at} `errore

produce errore poiché la variabile $largeArray_at non è stato dichiarato.

La soluzione è quindi dichiarare come Longint le variabili da usare come indici di puntatori ad array di grandi dimensioni.

I parametri aggiuntivi di LAUNCH EXTERNAL PROCESS permettono di riempire una variabile $output con lo standard output del comando lanciato. Ecco un esempio.

C_TEXT($input;$error;$output)
$input:=Char(34)+$percorsoprogramma+Char(34)+" "+$altriparametri+Char(13)+Char(10)
SET ENVIRONMENT VARIABLE("_4D_OPTION_HIDE_CONSOLE";"true")
LAUNCH EXTERNAL PROCESS("cmd.exe";$input;$output;$error)

E' possibile usare i comandi SVG per conoscere la dimensione di un testo.
Analizziamo il seguente codice:

C_PICTURE(immagine)
C_TEXT(root;ref)
C_LONGINT(larghezza;altezza)
root:=DOM Create XML Ref("svg";"http://www.w3.org/2000/svg")
ref:=DOM Create XML element(root;"text";\ //crea il testo
    "font-family";"Arial";\ //set font
    "font-size";"11";\ //set size
    "font-weight";"bold";\ //set style
    "y";"1em") //set Y coordinate
DOM SET XML ELEMENT VALUE(ref;"TESTO DI ESEMPIO")
SVG EXPORT TO PICTURE(root;immagine;Get XML Data Source)
DOM CLOSE XML(root)
PICTURE PROPERTIES(immagine;larghezza;altezza)

Il codice crea l'XML che corrisponde a un SVG che possiamo poi trasformare in immagine e conoscerne la dimensione.
In larghezza e altezza avremo quindi la dimensione del testo.

Per modificare l'elemento di una list box è necessario cliccarci due volte: il primo clic seleziona l'elemento, il secondo lo rende modificabile. Per fare in modo che un clic renda direttamente modificabile l'elemento si può uasre il seguente codice:

Case of
: (Form event=On Clicked )
    ` mi asssicuro che non stia facendo una selezione mutipla
      If (Not(Shift down | Windows Ctrl down))
           LISTBOX GET CELL POSITION(*;"ListBox";col;row;colVar_p)
           EDIT ITEM(colVar_p->;row)
      End if
End case

I seguenti nomi di variabili sono riservati a 4D:

C1, C2, C3, C4, C5, ecc. (usate nei report)
OK
Document
Error
KeyCode
Modifiers
MouseDown
MouseProc
MouseX
MouseY
FldDelimit
RecDelimit

Non devono dunque essere usate se non nel contesto cui si riferiscono: ad esempio Document contiene il percorso del documento dopo aver usato Open document, Create document o Append document ed è stato scelto un file mostrando la dialog di sistema per l'apertura o il salvataggio di un file.

Il method editor di 4D nella v12 è stato completamente riscritto.

Tra le novità, una molto utile è la possibilità di visualizzare un help tip per i comandi di 4D, con definizione e una breve descrizione.

Possiamo però fare la stessa cosa anche con i nostri metodi:
  infatti, portando il mouse su un nostro metodo, non abbiamo bisogno di aprirlo per vedere cosa faceva perché come help tip vengono visualizzate tutte le righe iniziali del metodo che siano commento (e che non siano quindi codice).

Prendendo quindi l'abitudine di commentare i metodi nella loro parte iniziale con la loro definizione e descrizione, diventerà agevole conoscere le info sul nostro codice.

Per conoscere tutte le proprietà legate (e quindi configurabili) di un oggetto in un'area SVG si usa il comando SVG_GET_ATTRIBUTES. Esso popola due array con i nomi e i valori degli attributi. Se $ref è l'ID dell'oggetto, utilizzeremo:

ARRAY TEXT($arrNames;0)
ARRAY TEXT($arrValues;0)
SVG_GET_ATTRIBUTES ($ref;->$arrNames;->$arrValues)

Volevo solo segnalarvi un modo per poter vedere il contenuto di variabili testo molto grosse durante il debug.

Io mi sono trovato molto spesso in condizioni simili e devo dire che era molto difficile vedere il contenuto dopo un certo numero di caratteri. Molti usavano (io compreso) la save su disco per poterla aprire poi con un altro programma e controllarne il contenuto. Io mi sono trovato spesso a dover vedere il contenuto di una variabile che era un file xml, ed era molto frustante dover interrompere il debug per mettere codice per salvare il file.

Un metodo semplice ed efficace è quello di usare il comando :

SET TEXT TO PASTEBOARD ( text )

Quindi quando siete fermi sul vostro break nel riquadro delle variabili inserite il comando, sostituite "text" con la vostra variabile e a quel punto avrete il contenuto nel clipboard. Facendo incolla su textedit avrete il contenuto della variabile ben leggibile.

Se all'interno della stessa area di testo SVG devo inserire diversi stili (ad esempio una parola in tondo, una seconda in grassetto e una terza in corsivo), il comando da utilizzare è SVG_New_tspan.

A differenza della gran parte dei comandi SVG, SVG_New_tspan prende come parametro l'ID dell'area di testo (definita da un precedente SVG_New_text o SVG_New_tspan) a cui il nuovo testo deve essere collegato.
Quindi:

$textID:=SVG_New_text($SVG;"Scrivere ";10;10;"arial";12)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"con ");14)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"SVG ");18)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"è ");24)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"facile");36)

definisce l'area di testo, quindi inserisce il testo aggiuntivo, modificandone al volo la dimensione.

Il modo più agevole per inserire un testo in un'area SVG è il comando SVG_New_text. Il suo uso più semplice è:

$SVG:=SVG_New
$textID:=SVG_New_text($SVG;"Test SVG")

che crea un'area SVG e scrive il testo desiderato.
I parametri aggiuntivi utilizzabili sono svariati e permettono di impostare posizione del testo, dimensione, allineamento, stile e tipo del carattere, rotazione e spaziatura. La sintassi completa è:

SVG_New_text ( parentSVGObject ; text {; x {; y {; font {; size {; style {; alignment {; color {; rotation {; lineSpacing {; stretching}}}}}}}}}} )

Il comando restituisce l'ID dell'elemento inserito.

Ecco un elenco dei vari standard:

• esecuzione diretta script PHP 5.3 con interprete compilato FastCGI
  
• supporto XML versione 1.0 con la libreria Xerces di Apache Foundation:
  • standard DOM (Document Object Model)
  • il SAX (Simple API XML)
  • la notazione XPath (per il DOM)
  • le trasformazioni tramite XSL style sheets (eXtended Stylesheet Language)
  
  
• gestione di quattro tipi di Metadati per le immagini: EXIF, GPS, IPTC e TIFF
  
• gestione del forma SVG ((Scalable Vector Graphics), sia come visualizzazione che creazione e modifica
  
• supporto dell'architettura standard XLIFF (XML Localization Interchange File Format) per la localizzazione dell'interfaccia
  
• supporto dei WebService, sia come server che come client
  • generazione automatica del WSDL (Web Service Description Language) come server e interpretazione degli stessi per la generazione del codice client
  • protocolli SOAP (versione 1.1 e versione 1.2)
  • RPC (Remote Procedure Call)
  • DOC (Document-oriented)
  
  
• il Web Server è compatibile HTML 1.1, supporta documenti XML, la tecnologia WML (Wireless Markup Language), il protocollo SSL (Secured Socket Layer)
  
• supporta le CGI e può essere chiamato tramite CGI da altri web server
  
• utilizzando il web server sui client è possibile realizzare facilmente il Load Balancing
  
• disponibilità di un 4D AJAX Framework, per creare pagine web collegate e distribuite dal server 4D
  
• disponibilità di un 4D for Flex, che permette alle applicazioni Flex di collegarsi direttamente al server 4D
  
• supporta le chiamate via ODBC con driver nativo anche per Macintosh
  
• supporta le chiamate via PDO_4D da PHP
  
• supporta chiamate dirette server to server con altri server 4D
  
• può interrogare altri database via protocollo ODBC e OCI (Oracle Call Interface)
  
• comandi per interrogazione server posta POP3 e IMAP, Internet Message Access Protocol, Version 4 revision 1 (IMAP4rev1)
  
• comandi per l'invio di posta tramite server SMTP, con allegati, destinatari, destinatari in copia CC (Carbon Copy ) e in copia nascosti BCC (Blind Carbon Copy ), autenticazione (CRAM-MD5, LOGIN, PLAIN), commenti
  
• comandi per la gestione diretta dei server FTP (File Transfer Protocol)
  
• comandi di basso livello TCP/IP, UDP, utility come Ping e Name resolver

Fra i vari strumenti della palette 4dPop (inclusa nell'ambiente di sviluppo di 4d) ce n'è uno tanto pieno di funzioni quanto poco notato dai programmatori: 4DPop Macros.

Oggi parliamo della macro Incolla Speciale, che elabora un testo prima di incollarlo nel codice.

Richiamandola, ci sono diverse opzioni da scegliere e un'area di anteprima:

String
Incolla il testo fra apici e sostituendo i caratteri speciali (return, tab, etc) con gli equivalenti per le stringhe (\r, \t, etc)

Comments
Incolla il testo già commentato

HTML
Incolla il testo spezzandolo in diverse righe e aggiungendolo ad una variabile testo (utile per generare via codice una pagina web)



Regex Pattern
Incolla il testo sostituendo i caratteri sinificativi per le regex con l'equivalente con lo slash (ad esempio * diventa \*)

Code from 4D v11 FR
Incolla il testo traducendolo dal codice di 4d in francese, utile ad esempio per utilizzare un metodo inviato sul forum di 4d da un francese.

Fra i vari strumenti della palette 4dPop (inclusa nell'ambiente di sviluppo di 4d) ce n'è uno tanto pieno di funzioni quanto poco notato dai programmatori: 4DPop Macros.

Oggi parliamo della sola macro Dichiarazioni, che scrive automaticamente le dichiarazioni per le variabili locali in un metodo.

Richiamandola, appare una maschera dove compare la lista delle variabili:
- In grassetto quelle riconosciute
- In grassetto sottolineato gli array riconosciuti
- In corsivo le variabili da identificare



Alla destra della lista sono elencati i tipi da assegnare alle variabili non riconosciute, con la possibilità di usare la tastiera per velocità.

In realtà, se si usa una nomenclatura delle variabili coerente, esiste la possibilità che questa macro assegni automaticamente i tipi senza il nostro intervento.
Usando il tasto Options si accede ad un pannello dove è possibile indicare lo schema usato nei propri programmi per assegnare i nomi, ad esempio:

Lon_* = indica le variabili che iniziano per "Lon_"
*Lon_* = indica le variabili che contengono "Lon_"
*A(\d\d)_* = indica le variabili che iniziano per A seguita da 2 cifre

Con la v12 sono disponibili degli oggetti (chiamati widget) che sono predisposti per essere riutilizzati nelle maschere di 4d.

Ad esempio si può trovare il campo di ricerca (con stile differente su Mac e su Windows) che si chiama SearchPicker.




Per utilizzarlo si può:
- sceglierlo dalla libreria degli oggetti (nella v12 icona dei libri nella barra superiore del form editor)

oppure

- creare un subform e assegnarli il tipo "Detail" col nome "SearchPicker"

Il subform avrà una variabile che è quella che contiene il valore inserito; il pulsantino di cancellazione è automatico, mentre il testo in grigio (il suggerimento) che sparisce appena si scrive viene definito con il comando SearchPicker SET HELP TEXT.

Il backup di solito viene lanciato in ore notturne o quando non ci sono normalmente utenti online; oppure il server non è facilmente accessibile... come fare a controllare che il backup sia andato a posto?

E' possibile utilizzare il metodo Database che si chiama "On Backup Shutdown Database Method"; questo metodo viene chiamato automaticamente alla fine del processo di backup, con parametro $1 = 0 se tutto è andato a posto o # 0 se ci sono stati problemi.

C_LONGINT($1;$backupStatus)
C_DATE($data)
C_TIME($ora)
C_REAL($num)
C_TEXT($status)
$backupStatus:=$1
If ($backupStatus#0)
  GET BACKUP INFORMATION(Last Backup Date ;$data;$ora)
  GET BACKUP INFORMATION(Last Backup Status ;$num;$status)
  $messaggio:="Errore nel backup numero "+string($backupStatus)+"\r\r"
  $messaggio:=$messaggio+"Ultimo Backup: "+String($data)+" alle "+String($ora)+"\r"
  $messaggio:=$messaggio+"Stato: "+$status
  $res:=smtp_quickSend(<>serverSmtp ; <>mailMittente ; <>mailDestinatario ; "Errore durante il backup"; $messaggio)
End if

Per maggior chiarezza e miglior controllo, alcuni tag HTML sono stati modificati in 4d v12.2:

• 4DHTMLVAR è sostituito da 4DHTML
• 4DVAR -> obsoleto, al suo posto usa:
  -> 4DHTML per inserire una variabile 4d o una espressione come codice Html
  -> 4DTEXT per inserie una variabile 4d o una espressione come testo

Note:
- Adesso 4DTEXT non accetta più il char(1) come primo carattere per interpretarlo come HTML, che era il primo vecchio meccanismo per supportare le due varianti di 4DVAR.
- Le vecchie varianti sono ancora supportate, ma essendo dichiarate obsolete dalla 12.2 sarà meglio cominciare ad usare la nuova nomenclatura

Occorre innanzitutto installare il componente "RichTextArea.4dbase" nella cartella Components a livello della struttura .4db o nella cartella Components all'interno dell'applicativo 4d.

Nel form dove si vuole modificare un campo testo va creata una subform, impostando tipo TEXT e una variabile, ad esempio txtMioWord.

Nel metodo legato al form carico la variabile con il contenuto del campo:

Case of
  : (Form event=On Load)
  txtMioWord:=[Tabella]CampoTesto
End case

Mentre nel metodo della subform, aggiorno il campo con la variabile:

Case of
  : (Form event=On Data Change)
  [Tabella]CampoTesto:=txtMioWord
End case

Quando si tenta di connettere un client a un server v11 e successivi e appaiono questi errori:
-10509 Can't open database
1024 Cannot open structure of database
1211 Cannot create connection
4 <<Localizator is not available.>>

Vuol dire che la porta precedente e quella successiva alla porta di comunicazione client/server non sono accessibili, normalmente a causa di un firewall-

La porta di default è la 19813: anche la 19812 e la 19814 dovrebbero essere aperte.

Ecco un esempio di utilizzo di Match regex per verificare un indirizzo tcp/ip ed estrarne le diverse cifre.

Si basa su:
- il simbolo \d = una cifra
- gli operatori {min,max} indicano quante ripetizioni cercare
- gli operatori () isolano i diversi gruppi trovati

    // ----------------------------------------------------
    // User name (OS): Umberto Migliore
    // Date and time: 01-03-11, 23:48:44
    // ----------------------------------------------------
    // Method: regex
    // Description
    //
    //
    // Parameters
    // ----------------------------------------------------

ARRAY LONGINT($arrayPosizioni;0)
ARRAY LONGINT($arrayLunghezze;0)
C_BOOLEAN(isTcpCorretto)
C_TEXT($stringa;$1)

$stringa:=$1` per esempio "192.168.0.1"

isTcpCorretto:=Match regex("(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})";$stringa;1;$arrayPosizioni;$arrayLunghezze)

If (isTcpCorretto)
  $numero1:=Substring($stringa;$arrayPosizioni{1};$arrayLunghezze{1})
  $numero2:=Substring($stringa;$arrayPosizioni{2};$arrayLunghezze{2})
  $numero3:=Substring($stringa;$arrayPosizioni{3};$arrayLunghezze{3})
  $numero4:=Substring($stringa;$arrayPosizioni{4};$arrayLunghezze{4})
End if

Continuiamo ad analizzare i pattern possibili per il comando Match regex.

- {...} definiscono un numero di ripetizioni della espressione regolare precedente. Può essere usato nella forma:
{n} l'espressione regolare deve essere ripetuta n volte
{min,} l'espressione regolare deve essere ripetuta almeno min volte
{min, max} l'espressione regolare deve essere ripetuta almeno min volte e massimo max volte

- | (la pipe) definisce più opzioni (il classico OR). Quindi:

• "4|d" corrisponde a "d"
  
• "4|d" non corrisponde a "b"
  

- (...) definiscono i gruppi. È possibile infatti ottenere sia delle stringhe di corrispondenza che delle sottostringhe, quelle che corrispondono ai pattern fra parentesi. Quindi:

• "(4+)d" corrisponde a "4d". Subpattern: {"4"}
  

Il nuovo comando SET QUERY AND LOCK, che prende come parametro semplicemente True o False, permette di richiedere il blocco dei record risultanti da una query. Ciò garantisce che i risultati di una certa ricerca non possano essere modificato da un altro processo che non sia quello attuale.

Il comando può essere usato solo all'interno di una transazione (altrimenti restituisce errore), e i record restano bloccati finché la transazione viene terminata: a quel punto i record vengono comunque rilasciati. Basta comunque chiamare SET QUERY AND LOCK(False) per rilasciarli.

Ecco un esempio di cancellazione controllata da SET QUERY AND LOCK:

START TRANSACTION
SET QUERY AND LOCK(True)`così mi assicuro che i record trovati siano locked per gli altri
QUERY([Clients];[Clients]Category=“C”)
DELETE SELECTION([Clients])
SET QUERY AND LOCK(False)
VALIDATE TRANSACTION

Con la v12 è ora possibile usare SET PRINT OPTION per stampare su PDF anche sotto Windows (su Mac il PDF è nativo).

Per farlo è necessario installare il driver gratis (OpenSource) PDFCreator sotto la licenza AFPL (Aladdin Free Public License). Per maggiori informazioni fare riferimento a questo link: Licenza PDFCreator

La versione attualmente certificata è la 0.9.9 che si scarica da qui: PDFCreator 200.9.9.

E' necessario avere i diritti di Amministratore: verrà creata una nuova stampante virtuale chiamata di default "PDFCreator" .

Il comando Match regex permette di fare operazioni particolari sulle stringhe. La forma base del comando è:

Match regex (pattern; aString)

dove aString è la stringa dove effettuiamo la ricerca, pattern è una speciale stringa che contiene "cosa" cercare. Se pattern si trova all'interno di di aString il comando ritorna True. Ecco cosa si può inserire all'interno di pattern.

- il caso più ovvio: se pattern:="mytext" e aString:="mytext", il comando ritorna True

- . (il punto) corrisponde a "qualsiasi carattere" tranne new line (a meno che ciò non venga espressamente specificato nelle opzioni inseribili in pattern). Quindi:

• "4.b" corrisponde a "4db"
  
• "4.r" non corrisponde a "4dfr"
  

- [ ... ] definisce classi di caratteri. Come:

"[a-z]" corrisponde a qualsiasi lettera minuscola

Se la classe inizia con "^", la classe viene negata, cioè esiste corrispondenza se i caratteri non sono nella classe.

- * (asterisco) corrisponde a zero o più operatori. Quindi:

• "z*" corrisponde a ""
  
• "z*" corrisponde a "zzzzz"
  
• "4d*b" corrisponde a "4dddb"
  
• "4d*b" non corrisponde a "4d"
  

- + (il segno più) corrisponde a uno o più operatori. Quindi:

• "z+" corrisponde a "z"
  
• "z+" non corrisponde a ""
  

? - corrisponde a zero o un operatore. Quindi:

• "a?" corrisponde a ""
  
• "a?" corrisponde a "a"
  
• "a?" non corrisponde a "aa"
  

Ecco, per finire, un estratto di codice per ricevere mai da GMail dal server POP.


$tempFolder:=Temporary folder
$error:=0
$sslPOPPort:=995
$Errore_l:=IT_SetPort (13;$sslPOPPort) //13 is for 'POP with SSL'
$error:=POP3_SetPrefs (-1;$tempFolder;$tempFolder)
$error:=POP3_BoxInfo ($pop3ID;$msgCount;$msgSize)
ARRAY LONGINT($aMsgSize;0)
ARRAY LONGINT($aMsgNum;0)
ARRAY TEXT($aMsgID;0)
$error:=POP3_MsgLstInfo ($pop3ID;1;$msgCount;$aMsgSize;$aMsgNum;$aMsgID)
For ($msgNumber;1;Size of array($aMsgNum))
`.......
`scarica la mail con POP3_Download
`cancellala con POP3_Delete
`scarica il messaggio con MSG_GetBody
`.......
End for
$error:=POP3_Logout ($pop3ID)

Quando si fanno dei collegamenti a server SQL esterni ci potrebbero essere dei problemi di transcodifica del set di caratteri.

Il comando che permette di definire il charset corretto è
SQL SET OPTION(SQL Charset ;<charset>)

Il valore del parametro charset è di default 106 che sta per UTF-8

Gli altri codici si trovano nella tabella di questa pagina : http://www.iana.org/assignments/character-sets

A volte però non è semplice identificare quale codice usare, per via delle varie combinazioni ad esempio di client usato da mac o da windows: una soluzione è usare il parametro -2 che si adatta alla piattaforma ( e cioè iso-8859-1 su windows e MacRoman su mac).

SQL SET OPTION(SQL Charset ;-2)

Ecco di seguito la parte di codice necessaria per autenticarsi al server IMAP di GMail e ricevere l'elenco dei messaggi di posta in entrata.


C_INTEGER($error;$sslIMAPPort)
C_LONGINT($smtp_id)
$tempFolder:=Temporary folder
$sslIMAPPort:=993
$error:=IT_SetPort (14;$sslIMAPPort) //14 is for 'IMAP with SSL'
$error:=IMAP_SetPrefs (-1;$tempFolder) //
$error:=IMAP_Login ("imap.gmail.com";"mymail@gmail.com";"mypassword";$imapID;1)

ARRAY LONGINT($aMsgSize;0)
ARRAY LONGINT($aMsgNum;0)
ARRAY LONGINT($aMsgID;0)
$error:=IMAP_SetCurrentMB ($imapID;"INBOX")
$error:=IMAP_MsgLstInfo ($imapID;1;$msgCount;$aMsgSize;$aMsgNum;$aMsgID)
$error:=IMAP_Logout ($imapID)

Grazie alle nuove funzionalità SSL degli Internet Command di 4D v12, è adesso possibile inviare messaggi attraverso il server smtp.gmail.com. Vediamo il metodo:


C_INTEGER($error;$sslSMTPPort)
C_LONGINT($smtp_id)
C_TEXT($smtpHost)
C_TEXT($gmailUser;$gmailPass;$replyTo;$sendEmailTo)
C_TEXT($msg;$subject)

$sslSMTPPort:=465 // port used for SSL SMTP - gmail wants 465
$smtpHost:="smtp.gmail.com" // smtp host for gmail
$gmailUser:="mymail@gmail.com" // gmail user
$gmailPass:="mypass" // gmail password
$replyTo:="mymail@gmail.com" // have replies sent here
$sendEmailTo:="test@sendmail.it" // send email here
$subject:="An example from sviluppo4d" // subject for email
$msg:="It works fine" // email body

$error:=IT_SetPort (12;$sslSMTPPort) //12 is for 'SMTP with SSL'

$error:=SMTP_New ($smtp_id)
$error:=SMTP_Host ($smtp_id;$smtpHost;0)
$error:=SMTP_Auth ($smtp_id;$gmailUser;$gmailPass;0)
$error:=SMTP_AddHeader ($smtp_id;"Importance";"Normal";0)
$error:=SMTP_From ($smtp_id;$gmailUser;1)
$error:=SMTP_ReplyTo ($smtp_id;$replyTo;0)
$error:=SMTP_To ($smtp_id;$sendEmailTo;0)
$error:=SMTP_Subject ($smtp_id;$subject;0)
$error:=SMTP_Body ($smtp_id;$msg;0)
$error:=SMTP_Attachment ($smtp_id;"c:\\aPDFdoc.pdf";7)
$error:=SMTP_Send ($smtp_id;1) //1 to use ssl
$error:=SMTP_Clear ($smtp_id)

// ----------------------------------------------------
    // User name (OS): Umberto Migliore
    // Date and time: 09-02-11, 23:55:55
    // ----------------------------------------------------
    // Method: nx_giornoPasquaPerLAnno
    // Description
    // Ritorna il giorno di Pasqua per l'anno
    //
    // Parameters
    // $1 = anno
    // ----------------------------------------------------

c_longint($anno;$1)
C_LONGINT($dopo21marzo)
C_DATE($pasqua;$0)

$anno:=$1
$phpok:=PHP Execute("";"easter_days";$dopo21marzo;$anno)
$pasqua:=Add to date(!00-00-00!;$anno;3;21+$dopo21marzo)
$0:=$pasqua

La v12 integra un comando molto utile per gestire le subform.

CALL SUBFORM CONTAINER(event)

invia un evento event (un longint) all'object method del "contenitore" della subform.
Il comando può trovarsi nel form method della subform o in uno degli oggetti della stessa.
L'evento event può essere o uno dei valori delle costanti 4D per i form events o un qualsiasi valore definito dall'utente (che viene gestito sempre nel metodo del contenitore).

Tale commistione di valori rende consigliabile l'uso di valori negativi per gli eventi "user defined" in modo che non vadano in conflitto con quelli predefiniti 4D.

Il comando RESTORE accetta adesso due parametri, entrambi opzionali:
- l'archivio da ripristinare;
- la cartella di destinazione per il ripristino.

Se il ripristino viene eseguito correttamente, la variabile OK viene settata ad uno e la variabile Document conterrà il percorso della cartella di ripristino; in caso contrario OK va a 0 e Document avrà come valore una stringa vuota.

4D v12 installa automaticamente i manuali in versione HTLM. Per i fan ("duri a morire" recita il sito di 4D) dei PDF, ecco dove trovare la documentazione nel formato Adobe:

Doc Center homepage

FTP site

In realtà, non si tratta di una reimpaginazione dei manuali: sono esattamente le pagine html in pdf.

  ` ----------------------------------------------------
    ` User name (OS): Umberto Migliore
    ` Date and time: 02-02-11, 10:51:05
    ` ----------------------------------------------------
    ` Method: nx_GetMemory
    ` Description
    ` se non passi parametri mostra un alert con tutti i valori correnti
    ` se passi una delle seguenti stringhe ritorna il valore specifico in KB
    ` 
    ` es. nx_GetMemory
    ` es. $memoriadisponibile:=nx_GetMemory("Free Memory")
    `
    ` $1 può essere:
    ` "cacheSize"
    ` "usedCacheSize"
    ` "Physical Memory Size"
    ` "Free Memory"
    ` "Used physical memory"
    ` "Used virtual memory"
    ` ----------------------------------------------------


ARRAY TEXT($arrNomi;0)
ARRAY REAL($arrValori;0)
ARRAY REAL($arrOggetti;0)

GET CACHE STATISTICS(1;$arrNomi;$arrValori;$arrOggetti)

If (Count parameters=0)
  
  C_TEXT($testo)
  $testo:=""
  For ($i;1;Size of array($arrValori))
    $testo:=$testo+$arrNomi{$i}+" : "+String($arrValori{$i}/1024;"### ### ### KB")+Char(13)
  End for
  ALERT($testo)

Else  `Count parameters>0

  C_TEXT($1;$parametro)
  $pos:=Find in array($arrNomi;$parametro)
  If ($pos>0)
    $0:=$arrValori{$pos}/1024  `i valori sono in bytes
  Else
    $0:=-1
  End if

End if

Ecco un esempio di utilizzo della tabella interna _USER_COLUMNS per esportare la struttura del database corrente.

ARRAY TEXT($nomeTabella;0)
ARRAY TEXT($nomeCampo;0)
ARRAY LONGINT($tipoCampo;0)
ARRAY LONGINT($lunghezzaCampo;0)
ARRAY BOOLEAN($accettaNULL;0)
ARRAY LONGINT($idTabella;0)
ARRAY LONGINT($idCampo;0)

Begin SQL
  SELECT * FROM _USER_COLUMNS
  INTO :$nomeTabella, :$nomeCampo, :$tipoCampo, :$lunghezzaCampo, :$accettaNULL, :$idTabella, :$idCampo
End SQL

// ordina per tabella e in secondo livello per idCampo
MULTI SORT ARRAY ($nomeTabella;>;$nomeCampo;$tipoCampo;$lunghezzaCampo;$accettaNULL;$idTabella;$idCampo;>)

$doc:=Create document($System folder(Desktop) +"struttura.text")
$ultimaTabella:=""
For ($i;1;Size of array($nomeTabella))
  If ($ultimaTabella#$nomeTabella{$i})
    SEND PACKET($doc;"\r"+$nomeTabella{$i}+"\t"+String($idTabella{$i})+"\r")
    $ultimaTabella:=$nomeTabella{$i}
  End if
  $tipo:=Choose($tipoCampo{$i};"-";"Boolean";"-";"Integer";"Longint";"Integer 64bits";"Real";"Float";"Date";"Time";"Alpha/Text";"-";"Picture";"-";"-";"-";"-";"-";"BLOB")
  SEND PACKET($doc;$nomeTabella{$i}+"\t"+$nomeCampo{$i}+"\t"+String($tipoCampo{$i})+"\t"+$tipo+"\t"+String($lunghezzaCampo{$i})+"\t"+String($accettaNULL{$i};"True;;False")+"\t"+String($idCampo{$i})+"\r")
End for
CLOSE DOCUMENT($doc)

In 4d è presente l'engine di visualizzazione delle immagini SVG, creabili con i comandi XML e alla fine trasformati in picture con il comando
SVG EXPORT TO PICTURE.

Ecco un esempio:

  C_PICTURE(miaPicture)
  $svg:=DOM Create XML Ref("svg";"http://www.w3.org/2000/svg")
ref:=DOM Create XML element(root;"text";\ //oggetto di tipo testo
    "font-family";"Arial";\ //con questo font
    "font-size";"26";\ //questa dimensione
    "font-weight";"bold") //questo stile
  DOM SET XML ATTRIBUTE($ref;"fill";"red") // posso aggiungere un attributo anche dopo
  DOM SET XML ATTRIBUTE($ref;"y";"1em") // imposto la posizione y
  DOM SET XML ELEMENT VALUE($ref;"Ecco un esempio")
  SVG EXPORT TO PICTURE($svg;miaPicture;Copy XML Data Source)
  DOM CLOSE XML($svg)

Dalla versione 12.1 è possibile inviare e ricevere mail utilizzando l'SSL come protocollo di scambio dati.
L'uso del protocollo non richiede nessuna configurazione particolare: basta passare il nuovo parametro a 1 nei seguenti comandi:

• IMAP_Login
• SMTP_Send
• SMTP_QuickSen
• POP3_Login

Invece il comando IT_SetPort ora accetta 3 nuovi valori per l'impostazione delle porte:
12 = SMTP SSL
13 = POP3 SSL
14 = IMAP SSL

Il comando SQL LOGIN accetta 3 parametri: la fonte dati, user e password.

La fonte dati può essere espressa in diversi modi:

- IP address
Sintassi: IP:<Indirizzo>{:<PortaTCP>}{:ssl}
In questo caso il comando apre una connessione diretta al 4D Server eseguito sulla macchina indicata dall'IP. Se non passi la porta TCP, verrà usata la porta standard 19812.
NOTA: se vuoi aprire una connessione in SSL, bisogna aggiungere ":ssl"

- nome pubblicato sulla rete del database 4D
Sintassi: 4D:<Nome_pubblicato>
In questo caso il comando apre una connessione diretta al 4D Server con il nome indicato. La porta TCP del server deve essere impostata allo stesso modo in entrambi i server.

- il nome di una data source ODBC
Sintassi: ODBC:<UserDSN> or <SystemDSN>
E' possibile indicare il nome di una sorgente dati impostata con l'amministratore ODBC.
Il prefisso non è obbligatorio per compatibilità con le versioni precedenti, ma è consigliato.

- stringa vuota
Sintassi: ""
Richiede la visualizzazione di una finestra di dialogo dove è possibile utilizzare vari pannelli per scegliere la connessione

- costante SQL_INTERNAL
Syntax: SQL_INTERNAL
In questo caso, il comando redireziona le richieste SQL al database interno.

Quando converti una data in testo, si usa il comando stringa che accetta come secondo parametro una delle seguenti costanti:

Blank if null date ritorna "" invece di 0
Date RFC 1123 Mon, 24 Jan 2011 23:00:00 GMT
Internal date abbreviated Jan 25, 2011
Internal date long January 25, 2011
Internal date short 25/01/2011
Internal date short special 25/01/11 (ma anche 25/01/1811)
ISO Date 2011-01-25T00:00:00
ISO Date GMT 2011-01-24T23:00:00Z
System date abbreviated 25/gen/2011
System date long martedì 25 gennaio 2011
System date short 25/01/11

E il terzo parametro? Serve per le costanti di tipo RFC o ISO per aggiungere anche l'ora; ad esempio:

String(Current date;Date RFC 1123;Current time)
Tue, 25 Jan 2011 07:07:12 GMT

String(Current date;ISO Date;Current time)
2011-01-25T08:07:12

Ecco un metodo per aggiungere l'icona del bundle dell'app nel Doc di Mac, ripreso dalla kb di 4d ( http://kb.4d.com/search/assetid=44532 ).

In pratica usa launch external process per modificare le impostazioni dell'applicazione Dock e poi la rilancia forzando la chiusura del processo.

` ---------------------------------------------------
` Project method: AddToDock
` Example: AddToDock("myApp";"/Applications/myApp.app")
` ---------------------------------------------------
` Programmer: Jeremy Sullivan
` Created: Mon, Mar 13, 2006 8:00 AM
` ---------------------------------------------------
` Description: Aggiunge un'applicazione al Dock di Mac OS X
` ---------------------------------------------------
` Parameters
` Passed:
` $1 TEXT - Il nome dell'applicazione come dovrebbe comparire nel Dock
` $2 TEXT - Percorso in formato Posix al bundle (inclusa l'estensione .app)
` ---------------------------------------------------

C_TEXT($1;$2;$applicationName_t;$applicationPath_t)
C_TEXT($command_t;$inputStream_t;$outputStream_t;$errorStream_t)

$applicationName_t:=$1 ` miaApp
$applicationPath_t:=$2 ` percorso posix, ad esempio: /Applications/miaApp.app

$command_t:="defaults write com.apple.dock persistent-apps -array-add "
$command_t:=$command_t+"'tile-data"
$command_t:=$command_t+"file-data"
$command_t:=$command_t+"_CFURLString"
$command_t:=$command_t+""+$applicationPath_t+""
$command_t:=$command_t+"_CFURLStringType0"
$command_t:=$command_t+"file-label"+$applicationName_t+""
$command_t:=$command_t+"file-type41"
$command_t:=$command_t+"tile-typefile-tile'"

LAUNCH EXTERNAL
PROCESS($command_t;$inputStream_t;$outputStream_t;$errorStream_t)
LAUNCH EXTERNAL PROCESS("killall -HUP Dock";$inputStream_t;$outputStream_t;$errorStream_t) ` rilancia il Dock

  

Per avere il percorso della cartella dove si trova il database in formato Unix (Posix) si può usare il comando GET 4D FOLDER con questa sintassi, disponibile dalla versione 4D 2004.5:

Database Folder Unix Syntax

  Il risultato sarà del tipo:

/Users/Documents/MioDatabase/


Questa caratteristica è utile soprattutto usando LAUNCH EXTERNAL PROCESS, che su Mac OS X accetta un percorso Unix (Posix).

Nella v12 è integrato un interprete PHP v 5.3.2 che può essere utilizzato come estensione al linguaggio di 4d. E' possibile lanciare script php creati al momento, usare i comandi nativi di php, dei moduli preinstallati o installarne di altri.


La sintassi é
PHP Execute ( percorsoScript {; funzione {; risultato {; param1} {; param2 ; ... ; paramN}}} ) -> Function result

Riportiamo un paio di esempi semplice di uso del comando, con percorsoScript="" perché passiamo una funziona nativa del php, explode.

ARRAY TEXT($arrayTesto;0)
    $p1 :=","
  $p2 :="11,22,33,44,55"
  $isOk :=PHP Execute("";"explode";$arrayTesto;$p1;$p2)
  
- $arrayTesto conterrà le stringhe "11", "22", "33", etc.


Invece passando come parametro per il risultato un array numerico, sempre con la stessa stringa di input:

ARRAY LONGINT($arrayNumerico ;0)
  $p1 :=","
  $p2 :="11,22,33,44,55"
  $isOk :=PHP Execute("";"explode";$arrayNumerico;$p1;$p2)

- $arrayNumerico conterrà i numeri 11, 22, 33, etc.

Per indicare il separatore fra cartelle nella v12 è stata introdotta una nuova costante che varia in funzione della piattaforma su cui è eseguito il codice, la Folder separator.

Quindi, il seguente codice avrà un risultato diverso su Mac e Windows:

$Percorso_T:=Get 4D folder(HTML Root Folder)
$Percorso_T:=$Percorso_T+"Immagini"+Folder separator+"Articoli"+Folder separator
$0:=Percorso_T

La tabella che si occupa di regolamentare gli accessi al database via SQL.

_USER_SCHEMAS
SCHEMA_ID - INT32 - Numero
SCHEMA_NAME - VARCHAR - Nome
READ_GROUP_ID - INT32 - Numero del gruppo in sola lettura
READ_GROUP_NAME - VARCHAR - Nome del gruppo in sola lettura
READ_WRITE_GROUP_ID - INT32 - Numero del gruppo in scrittura
READ_WRITE_GROUP_NAME - VARCHAR - Nome del gruppo in scrittura
ALL_GROUP_ID - INT32 - Numero del gruppo con tutti i diritti (anche modifica della struttura)
ALL_GROUP_NAME - VARCHAR - Nome del gruppo con tutti i diritti

Ecco un'altra coppia di tabelle di sistema accessibili via SQL, con l'elenco delle relazioni, dei campi definiti come chiave primaria e delle regole di integrità referenziale (se cancello la testata cancello le righe, oppure non posso cancellare un record finché ci sono record in relazione.

_USER_CONSTRAINTS
CONSTRAINT_ID - VARCHAR - Numero identificativo della regola
CONSTRAINT_NAME - VARCHAR - Nome
CONSTRAINT_TYPE - VARCHAR - Tipo
TABLE_NAME - VARCHAR - Nome della tabella dove si trova la regola
TABLE_ID - INT64 - Numero della tabella con la regola
DELETE_RULE - VARCHAR - Regola di cancellazione con regola di integrità referenziale – CASCADE or RESTRICT
RELATED_TABLE_NAME - VARCHAR - Nome della tabella in relazione
RELATED_TABLE_ID - INT64 - Numero della tabella in relazione

Tipi di Constrain (o Regole):
P=chiave primaria o primary key
R= integrità referenziale - foreign key
4DR=relazione 4D

_USER_CONS_COLUMNS
CONSTRAINT_ID - VARCHAR - Numero identificativo della regola
CONSTRAINT_NAME - VARCHAR - Nome
TABLE_NAME - VARCHAR - Nome della tabella dove si trova la regola
TABLE_ID - INT64 - Numero della tabella con la regola
COLUMN_NAME - VARCHAR - Nome del campo con la regola
COLUMN_ID - INT64 - Numero del campo con la regola
COLUMN_POSITION - INT32 - Posizione del campo
RELATED_COLUMN_NAME - VARCHAR - Nome del campo in relazione
RELATED_COLUMN_ID - INT32 - Numero del campo in relazione

Da notare che le relazioni Molti a uno di 4d non sono la stessa cosa delle relazioni creati via SQL Primary Key e Foreign Key; nella Struttura anche dal punto di vista grafico sono rappresentate in maniera diversa.

Relazioni 4d:


Primary Key e Foreign Key SQL:

La seguente coppia di tabelle accessibili da SQL contengono le informazioni sugli indici:

_USER_INDEXES
INDEX_ID - VARCHAR - Numero identificativo dell'indice
INDEX_NAME - VARCHAR - Nome (potrebbe essere vuoto)
INDEX_TYPE - INT32 - Tipo
TABLE_NAME - VARCHAR - Nome della tabella dove si trova l'indice
TABLE_ID - INT64 - Numero della tabella dove si trova l'indice
UNIQUENESS - BOOLEAN - Vero se l'indice prevede l'unicità

I Tipi di indice sono:
1 BTree / Composite
3 Cluster / Keyword
7 Auto


_USER_IND_COLUMNS
INDEX_ID - VARCHAR - Numero identificativo dell'indice
INDEX_NAME - VARCHAR - Nome (potrebbe essere vuoto)
TABLE_NAME - VARCHAR - Nome della tabella dove si trova l'indice
COLUMN_NAME - VARCHAR - Nome del campo dove si trova l'indice
COLUMN_POSITION - INT32 - Posizione del campo
TABLE_ID - INT64 - Numero della tabella
COLUMN_ID - INT64 - Numero del campo

Ecco per esempio il codice per cancellare tutti gli indici di un db:

ARRAY TEXT($identificativi;0)
Begin SQL
    select Index_Id from _User_Indexes into :$identificativi;
End SQL
For ($i;1;Size of array($identificativi))
        $id:=$identificativi{$i}
        $tablenum:=0
        $fieldnum:=0
        Begin SQL
           select table_id, column_Id from _User_Ind_Columns
           where Index_ID = :$id limit 1 into :$tablenum, :$fieldnum;
        End SQL
        If (($tablenum#0) & ($fieldnum#0))
           $puntCampo:=Field($tablenum;$fieldnum)
           DELETE INDEX($puntCampo;*)
        End if
End for

Questa tabella accessibile da SQL dà un elenco dei campi divisi per le tabelle del database:

_USER_COLUMNS
TABLE_NAME - VARCHAR - Nome della tabella
COLUMN_NAME - VARCHAR - Nome del campo
DATA_TYPE - INT32- Tipo del campo
DATA_LENGTH - INT32- Lunghezza del campo
NULLABLE- BOOLEAN - Vero se il campo accetta valori NULL
TABLE_ID - INT64 - Numero della Tabella
COLUMN_ID - INT64 - Numero del campo

Il campo Tipo contiene:

1 - Boolean
3 - Integer
4 - Long Integer
5 - Integer 64 Bits
6 - Real
7 - Float
8 - Date
9 - Time
10 - Alpha (DATA_LENGTH = ((dimensione del campo)*(2))+4
10 - Text (Lo distingui perché ha DATA_LENGTH = 0 )
12 - Picture
18 - BLOB

Con la v12 è possibile avere testo formattato, utilizzando nel campo testo i tag HTML.

Per rimuovere i tag è possibile usare il comando OBJECT Get plain text. Interessante ad esempio per fare una ricerca all'interno di campi con testi con all'interno i tag html.

Cercando ad esempio "Apple iPhone" potresti non trovare il campo con scritto:
"<SPAN> STYLE="font-size:13.5pt">Apple</SPAN> iPhone"

La soluzione è usare :
QUERY BY FORMULA([articoli];OBJECT Get plain text([articoli]descrizione)="@Apple iPhone@")

Una delle funzioni aggiunte nella versione v12 è la gestione della replica dei dati, utile per sincronizzare più database in modo automatico a basso livello.

(cfr il comando Replicate su 4d )

La cosa interessante è che è possibile utilizzare questo comando anche sfruttando il protocollo HTTP: dovendo realizzare degli applicativi su piattaforma mobile la cosa semplifica di molto la comunicazione.

La modalità è di chiamare il nuovo URL specifico di 4d : /4DSYNC
E' possibile chiamarlo sia in lettura che in scrittura utilizzando stringhe costruite con la modalità JavaScript Objet Notation (JSON), abbastanza semplici sia da ottenere che interpretare.

La sintassi del comando è :

GET /4DSYNC/$catalog
Ritorna la lista delle tabelle per cui è attiva la replica e il numero di record che contengono.

GET /4DSYNC/$catalog/NomeTabella
Ritorna la descrizione della tabella.

GET /4DSYNC/NomeTabella/NomeCampo1{,NomeCampo2},...
Ritorna i dati dei campi indicati nella tabella.

POST /4DSYNC/NomeTabella/NomeCampo1{,NomeCampo2},...
Invia le modifiche fatte in locale al 4d.

Mentre fino alla versione 4d 11 il tempo consigliato per la flush cache era di default 15 minuti.

Dalla versione v12 il tempo consigliato è 20 secondi, grazie alle nuove ottimizzazioni del funzionamento della cache.

La più recente versione di 4D ha introdotto un nuovo metodo per il ripristino di una base dati danneggiata.

Oltre alla procedura standard (da usare quando indici o record sono danneggiati) è stato introdotto un "Recover by record headers" che permette il ripristino dei dati quando ad essere danneggiata è tabella degli indirizzamenti dei record, può essere utilizzato questo sistema assai più complesso.

Il procedimento è da utilizzare solo quando gli altri metodi non sono andati a buon fine. Al termine del processo non è garantita comunque l'unicità dei record (i record potrebbero comparire due volte) e il mantenimento della proprietà "Never null" dei campi. Infatti se nella tabella è stato deselezionato "Records definitively deleted" potrebbero ricomparire dei record eliminati.

Il sistema è diverso dal vecchio "Recover by tags" perché richiede l'intervento dell'operatore in quanto alcuni passi mostrano una finestra di richiesta conferma.

Ecco un elenco delle "Depercated features" che 4D ha segnalato come caratteristiche che verranno rimosse con le prossime versioni.

Cosa verrà rimpiazzato / Con cosa / da Quando
4D Chart (plug-in area) / SVG, webarea, PHP / Più avanti
4D Draw / SVG / (Rimosso dalla v11)
4D Open / Synchronization, WebServices, SQL Pass Thru / (Rimosso dalla v11)
PICT / Modern formats / Dipende dal Sistema
QuickDraw Patterns (form object property) / SVG, picture con “Replicated format” / Presto
Mac Resources / Usa “Resources” folder Sistema operativo
/ (Presto)
Old Looks / Usa System looks / Presto
Altura Mac2Win / Codice Windows nativo / Presto
SubTables / Usa tabelle N->1 / Più avanti
Web Contextual Mode / Usa il non-contextual mode / Presto
Non Unicode mode / Passa a Unicode / Presto

Ecco alcune impostazioni consigliate per l'uso di 4d su Windows Server 2003 e 2008:

Windows Processor Scheduling: settato a “Programs” invece di “background processes”.

Windows Memory: settato a “Programs” invece di “System Cache”.

Windows Page File: settato a “System Managed Size” invece di “Custom Size”.

La posizione di queste impostazioni varia da sistema a sistema, ma tipicamente si possono trovare in questo modo:

Fai clic su Start, poi Run, e scrivi "sysdm.cpl".

Nella finestra System Properties, fai clic sul tab Advanced, e poi clic su Settings sotto Performance.

Le raccomandazioni si applicano sia a 4d Monoutenza che Server, sia quando viene lanciato come servizio che in modalità utente.

I seguenti comandi sono stati dichiarati obsoleti e andrebbero sostituiti dalla versione 11 in avanti:

Deactivated
Activated
In Header
In Break
In Footer
Before
During
After
Outside call

Quindi i pezzi di codice nei metodi dei form di questo tipo:

If(Activated)
        ORDER BY([Tabella];[Tabella]Campo;>)
        ` ...
End if

Deve diventare così:

If(Form event=On Activate)
        ORDER BY([Tabella];[Tabella]Campo;>)
        ` ...
End if


Questa è la lista delle costanti del comando Form Event da utilizzare al posto dei vecchi comandi:

Command Form Event
Deactivated -> On Deactivate
Activated -> On Activate
In Header -> On Header
In Break -> On Printing Break
In Footer -> On Printing Footer
After -> On Validate

I comandi Before e During sono un po' più complessi:

Command Form Event
Before -> On Load
Before -> On Display Detail
Before -> On Printing Detail
During -> On Clicked
During -> On Double Clicked
During -> On Losing Focus
During -> On Getting Focus
During -> On Menu Selected
During -> On Data Change
During -> On Close Box
During -> On Printing Detail
During -> On Open Detail
During -> On Close Detail

Ad esempio a volte si usava la coppia Before e During assieme:
(Before & During) -> On Display Detail

Versione del metodo che elimina gli spazi dall'inizio e dalla fine di una stringa usando il comando Match Regex e due semplici regular espressions.

C_TEXT($miaStringa;$1)
C_TEXT($0;$risultato)
C_TEXT($pattern)
C_LONGINT($inizio;$dove;$lunga)
C_BOOLEAN($trovato)
$miaStringa:=$1
$inizio:=1
$foundFlag:=False

    `pattern regex per gli spazi all'inizio
    `^ -- indica l'inizio da dove cercare
    `\s+ -- search for one or more white spaces
$pattern:="^\\s+"

$trovato:=Match regex($pattern;$miaStringa;$inizio;$dove;$lunga)
If ($trovato)
$miaStringa:=Substring($miaStringa;$lunga+1)
End if
    `pattern regex per gli spazi alla fine della stringa
    `$ -- indica la fine dove cercare
$pattern:="\\s+$"

$trovato:=Match regex($pattern;$miaStringa;$inizio;$dove;$lunga)
If ($trovato)
$miaStringa:=Substring($miaStringa;$inizio;$dove-1)
End if
$0:=$miaStringa

In accordo con le specifiche SQL, 4th Dimension contiene delle tabelle di sistema che descrivono la struttura del database:

• _USER_TABLES
• _USER_COLUMNS
• _USER_INDEXES
• _USER_CONSTRAINTS
• _USER_IND_COLUMNS
• _USER _CONS_ COLUMNS
• _USER_SCHEMAS

.

La prima che andiamo ad analizzare è la _USER_TABLES, che contiene la descrizione delle tabelle del database. I campi che la compongono sono:

TABLE_NAME - VARCHAR - Il nome della tabella;
TEMPORARY - BOOLEAN - Vero se la tabella è temporanea, altrimenti Falso;
TABLE_ID - INT64 - Il numero della tabella;
SCHEMA_ID - INT32 - Il numero dello schema;

Così, come segnalato da Francesco Pandolfi sul NUG italiano, è possibile controllare se una tabella con un certo nome esiste usando il codice:

C_INTEGER($cnt)
C_TEXT($tabName)
$tabName:=$1

Begin SQL
        select count(*) from _user_tables
        where table_name = :$tabName
        into :$cnt;
End SQL

If ($cnt>0)
           `esiste
Else
           `non esiste
End if

Ecco di seguito un metodo per cercare un qualsiasi dato fra i campi alfanumerici di un database. Quando ogni dato viene trovato, restituisce un messaggio con tabella e campo in cui si trova il valore.


$quanti:=Get last table number
For ($i;1;$quanti)
  If (Is table number valid($i))
      For ($j;1;Get last field number($i))
        If (Is field number valid($i;$j))
           GET FIELD PROPERTIES($i;$j;$fieldType;$fieldLen;$indexed)
           If (($fieldType=Is Alpha Field ) | ($fieldType=Is Text ))
           $valoreSt:=$1
           $tabellaptr:=Table($i)
           $campoptr:=Field($i;$j)
           QUERY($tabellaptr->;$campoptr->=$valoreSt)
           If (Records in selection($tabellaptr->)>0)
           ALERT("["+Table name($i)+"]"+Field name($i;$j))
           End if
           End if
          End if
      End for
    End if
End for
ALERT("Finito")

Col seguente codice si può chiedere a 4D se una tabella esiste:



C_TEXT($1) ` Table name
C_BOOLEAN($0)

C_LONGINT($i)

$i:=1
$0:=False
While(($i<=Get last table number)&(Not($0)))
If (Is table number valid($i))
If (Table name($i)=$1)
$0:=True
End if
End if
$i:=$i+1
End while



Una variante può permettere di sapere il numero di tabella, se non esiste restituisce -1:


C_TEXT($1) ` Table name
C_LONGINT($i;$0)

$i:=1
$0:=-1
While($i<=Get last table number)
If (Is table number valid($i))
If (Table name($i)=$1)
$0:=$i
$i:=Get last table number+1
End if
End if
$i:=$i+1
End while

Dalla versione v11 i manuali non vengono più installati con le applicazioni.

Questo è l'indirizzo dove trovare i manuali di 4d in inglese:
http://www.4d.com/support/documentation.html

Per chi vuole consultare la guida online, l'indirizzo è:
http://www.4d.com/docs/4DDOCUS.HTM

Per configurare il percorso dell'help richiamabile con il tasto F1 nelle preferenze va scritto questo:
http://www.4d.com/docs/

Può capitare di dover associare a un pulsante più scorciatoie da tastiera: il caso più classico è un pulsante a cui è associato il pulsante "Carriage return" al quale si vuole associare anche il pulsante "Enter".

Ovviamente una possibilità è quella di duplicare varie volte il pulsante (con pulsanti nascosti), e a ogni copia assegnare la scorciatoia desiderata: l'inconveniente è che la modifica del codice di un pulsante costringe a modificare (o duplicare nuovamente) tutti gli altri.

Soluzione più agevole è quella di far invece "puntare" tutti i pulsanti copia al pulsante principale. Nell'esempio visto prima, nell'On clicked del metodo del pulsante associato ad "Enter" ci sarà scritto:

POST KEY(Carriage return)

La particolarità di un campo NULL sta proprio nel suo valore "speciale". Per tale motivo, se viene eseguita una query cercando una stringa vuota, i campi alpha/text contenenti il valore NULL non saranno presi in considerazione: questo significa che per trovare tali record è necessario scrivere del codice aggiuntivo.
Per evitare tali problematiche è possibile attivare nelle proprietà del campo l'opzione Map NULL values to blank values; questa, infatti, agisce a un livello molto basso del database, poiché assimila i valori NULL ai valori di default (stringa vuota, data 00/00/00, ecc.) del relativo campo.
Questa opzione è sempre attiva in automatico per ogni campo.

Quando si gestiscono dei valori NULL, 4D esegue in automatico delle conversioni quando questi valori vengono usati.
Se viene infatti eseguita l'istruzione:

miaAlphavar:=[table1]MioAlphafield

la variabile miaAlphavar prenderà il valore "".
In generale, le conversioni a tali valori di default vengono eseguite secondo questo schema:

• Per Alpha e Text: ""
• Per Real, Integer e Long Integer: 0
• Per Date: 00/00/00
• Per Time: 00:00:00
• Per Boolean: False
• Per Picture: immagine vuota
• Per Blob: blob vuoto

Con la versione 11 e l'introduzione del motore SQL, anche con 4D è possibile gestire i valori NULL. Un esempio di campo NULL è un booleano che contiene i valori Maschio/Femmina quando si censisce un'anagrafica: finché l'utente non setta il valore corretto il valore del campo è NULL.

Per impostare il valore di un campo a NULL si usa il comando SET FIELD VALUE NULL, mentre per sapere se il valore del campo è NULL si usa il comando Is field value Null.

Utilizzando due diversi server SMTP di Telecom Italia (un ADSL standard e un Interbusiness) per inviare dei pdf ad un servizio di fax server, su uno dei due capitava che il messaggio consegnato non fosse il pdf inviato, bensì un fax che recitava: "Il file è stato rimosso perché potenzialmente pericoloso".
Dopo varie richieste ai tecnici Telecom si è trovata la causa: l'attach veniva inviato come UUEncode utilizzando

SMTP_Attachment ( smtp_ID ; fileName ; encodeType ; deleteOption )

dove encodeType valeva 7.
Ora, il file veniva codificato al momento dell'esecuzione del comando SMTP_Send. Ciò però comportava che la dimensione comunicata (del file di partenza) e quella reale (del file codificato) risultassero diverse, facendo credere al server SMTP che al file allegato fosse stato agganciato del codice malevolo.

La soluzione è stata però agevole: è bastato infatti utilizzare il comando

IT_Encode ( fileName ; encodedFile ; encodedMode )

utilizzando come encodedMode sempre 7, UUEncode.
A questo punto basta eseguire SMTP_Attachment come prima ma usando come file da allegare encodedFile e come encodeType il valore -7, che per 4D significa che il file allegato è già codificato come UUEncode.

Non variando a questo punto la dimensione dell'allegato, il file viene correttamente inviato.

CREATE SELECTION FROM ARRAY permette di creare selezioni ordinate di record.

Supponiamo di voler utilizzare dei record in un ordine ben preciso (per esempio i clienti in ordine di fatturato, dove il fatturato deve essere calcolato "al volo").

Una soluzione è popolare un array con i record number dei clienti e il loro fatturato, ordinare i due array secondo quello col fatturato poi usare. Ecco un codice di esempio:

SELECTION TO ARRAY([Tabella];$arrayRecordNumer;[Tabella]campoX;$arrayX;Tabella]campoY;$arrayY)
ARRAY REAL($arrayFatturato;size of array($arrayRecordNumer))

`... elaboro i campi X e Y per ottenere il fatturato che vado a scrivere nell'iesimo elemento del nuovo array arrayFatturato

SORT ARRAY($arrayFatturato;$arrayRecordNumer)
CREATE SELECTION FROM ARRAY ([Tabella]; $arrayRecordNumer; "")

Con l'ultimo comando creo la selezione ordinata.

Benchè le variabili testo di 4D abbiano superato il limite di 32K ci sono ancora dei comandi che hanno parametri testo che richiedono questo limite. Uno di questi è SMTP_Boby che richiede che il teso passato sia ancora limitato a 32K.
Se usate delle righe di codice come le seguenti per creare il corpo della email.

  $offset:=0
  While ($offset<BLOB size(Mail_Blob))
    $body:=BLOB to text(Mail_Blob;Text without length ;$offset)
    $noError:=(ErrCheck ("SMTP_Body";SMTP_Body ($Smtp_id;$body;2)))
  End while

Ricordatevi che lo stesso metodo nella v11 to text deve diventare cosi:

  $body:=BLOB to text(Mail_Blob;Text without length ;$offset;$maxsize)
  $offset:=0
  $maxsize:=30000
  While ($offset<BLOB size(Mail_Blob))
    $body:=BLOB to text(Mail_Blob;UTF8 Mac Text without length ;$offset;$maxsize))
    $noError:=(ErrCheck ("SMTP_Body";SMTP_Body ($Smtp_id;$body;2)))
  End while

dove $maxsize deve essere inferiore o uguale a 32K

E' possibile spegnere automaticamente il computer utilizzando il comando LAUNCH EXTERNAL PROCESS.
Il comando deve essere eseguito nel "On Exit" (se serve distinguere fra versioni monoutente, client o server, e in caso usare "On Server Shutdown") così:

LAUNCH EXTERNAL PROCESS("shutdown -s -t 100";$tIn;$tOut)

attendendo 100 secondi prima di spegnere la macchina (un tempo ragionevole per pensare che 4D sia uscito). Se si aggiunge il parametro -f:

LAUNCH EXTERNAL PROCESS("shutdown -s -t 100 -f";$tIn;$tOut)

Windows forzerà la chiusura dei processi.


Se mentre il sistema si sta chiudendo ci si ricorda che c'era qualcos'altro da fare, nel database method "On Sturtup" si può inserire:

LAUNCH EXTERNAL PROCESS("shutdown -a";$tIn;$tOut)

per annullare un precedente spegnimento avviato.

Il formato è la stringa di testo del tipo "###.###,00" con cui puoi modificare la modalità di visualizzazione di un numero (c'è anche per data, ora, booleano)

Mentre fino alla versione 2004 nel formato il punto e la virgola rispecchiavano le impostazioni del sistema corrente, nella versione v11 (finalmente!) il punto sta sempre per la posizione dei decimali e la virgola per il separatore delle migliaia.

Cioé rende il programma facilmente utilizzabile anche in quegli ambienti dove si usano impostazioni 'americane' pur trovandosi in italia, ad esempio.

Questa impostazione è di default per le strutture create con la v11, mentre per quelle convertite dalle versioni precedenti esiste l'opzione Use period and comma as placeholders in numeric formats in Preferenze - Design Compatibility.

La v11 SQL non consente più il cast in automatico dei dati con i comandi di ODBC.

Per essere più chiari, se cerco di importare in un array di tipo stringa dei dati che nella sorgente ODBC sono invece di tipo longint, l'array sarà riempito da stringhe vuote; a differenza della versione 2004, dove il cambio di tipo era automatico ( e peraltro abbastanza pericoloso per l'integrità dei dati, benché comodo per il programmatore! )

Se nella v11SQL viene eseguito il codice

OUTPUT FORM([Tabella];"Output")

e il form non esiste, 4D restituisce errore, a differenza della versione 2004, dove il form poteva anche non esistere.

Ecco una versione modificata per la v11 di un metodo di esportazione dati in un file testo.

C_TEXT($testo)
C_BLOB($blob)
$pointertable:=->[LaTabella]
For ($j;1;Get last field number($pointertable))
  If (Is field number valid(Table($pointertable);$j))
    $testo:=$testo+Field name(Table($pointertable);$j)+Char(Tab )
    If ($j      $testo:=$testo+Char(Tab )
    End if
  End if
End for
$testo:=$testo+Char(Carriage return )+Char(Line feed )
TEXT TO BLOB($testo;$blob)

ALL RECORDS($pointertable->)
ARRAY LONGINT($arrRecNum;0)
SELECTION TO ARRAY($pointertable->;$arrRecNum)
For ($i;1;Size of array($arrRecNum))
  GOTO RECORD($pointertable->;$arrRecNum{$i})
  $testo:=""
  For ($j;1;Get last field number($pointertable))
    If (Is field number valid(Table($pointertable);$j))
      $pointer:=Field(Table($pointertable);$j)
      If ((Type($pointer->)=Is Alpha Field ) | ((Type($pointer->)=Is Text )))
        $testo:=$testo+$pointer->
      Else
         $testo:=$testo+String($pointer->)
      End if
      If ($j<Get last field number($pointertable))
        $testo:=$testo+Char(Tab )
      End if
    End if
  End for
  $testo:=$testo+Char(Carriage return )+Char(Line feed )
  TEXT TO BLOB($testo;$blob;UTF8 text without length ;*)
End for
BLOB TO DOCUMENT("Export.txt";$blob)

Sarà pure una cosa scontata, ma ordinando un campo booleano in maniera crescente vengono visualizzati prima i valori "False" e poi i "True"

Mettiamo di avere una List Box legata ad una Named Selection : se voglio far in modo che 4D mi selezioni un record in particolare (ad esempio il primo) dopo un ordinamento, devo utilizzare il set dichiarato in Highligth Set e fare questo simpatico giro di set :


QUERY([Tabella];[Tabella]campoChiave=[TabellaMadre]chiave)
ORDER BY([Tabella];[Tabella]campoOrdinamento;<)
COPY NAMED SELECTION([Tabella];"miaLista") 'Set usato per la ListBox

$num:=Record number([Tabella])
GOTO RECORD([Tabella];$num)
CREATE SET([Tabella];"il_Primo")
COPY SET("il_Primo";"selezionati") 'Set dichiarato come highligth set

Due grosse novità:

1) si può stampare la listbox, anche su più pagine


2) posizionamento per coordinate degli oggetti in fase di stampa

La sequenza da fare è:

- OPEN PRINTING JOB
- seleziono una maschera con OPEN PRINTING FORM
- stampo il singolo oggetto con Print Object

Ecco alcune delle novità del nuovo Code Editor:

• uso del // per il commento
• zoom sul testo
• autocompletamento dei comandi Sql, delle tabelle e campi anche in sql
• autocompletamento delle variabili locali, proposte automaticamente nelle dichiarazioni
• il Selection to array (fino a 128 parametri) può essere splittato su più righe con il backslash
• si possono impostare bookmark con il ctrl-tasto di funzione
• evidenziazione delle modifiche in giallo, in verde quando sono salvate
• il breakpoint segue la riga dove è stato messo
• modalità di correzione delle maiuscole delle variabili (ad es in camelCase
• collapse di codice selezionato, tag con anteprima

Il file .4DLINK è il nuovo tipo che di file che consente di aprire i database 4D.
In linea generale sostituisce il file .PTH che consentiva di aprire un 4D Client con le opzioni utente memorizzate, ma in realtà contiene un numero molto maggiore di opzioni.

Il file si trova nella cartella:

• Windows Vista: C:\Users\UserName\AppData\Roaming\4D\Favorites v11\
• Windows XP: C:\Documents and Settings\UserName\Application
Data\4D\Favorites v11\
• Mac OS: Users/UserName/Library/Preferences/4D/Favorites v11/

dove UserName è il nome dell'utente del sistema.

Il file 4DLINK è un file XML che nella sua forma più semplice si presenta così:

<?xml version="1.0" encoding="UTF-8"?>
<database_shortcut structure_file="file:///C:/mio.4DB"
data_file="file:///C:/mio.4DD"/>

All'interno del file è possibile inserire tutta una serie di attributi, come ad esempio nome utente e passoword:

<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<database_shortcut is_remote="true" password="123"
server_database_name="Contabilità" server_path="contabilita.dominio.it"
user_name="Steve"/>

Uno degli aspetti introdotti dalla v11 SQL era stata la possibilità di sviluppare software multilingua grazie all'uso di XLIFF.

Con 4D v12 SQL viene data innanzitutto la possibilità di utilizzare una lingua diversa da quella impostata nel sistema operativo; ma soprattutto sarà possibile definire, all'interno di ogni processo, se deve essere utilizzato per quel processo un fie XLIFF differente, senza che ciò intacchi l'impostazione di base della lingua del database intero o degli altri processi attivi.

Dalla versione 11.5 è presente un documento vicino alla struttura chiamato nome_database.Match .

Il nuovo file è creato per collegare i numeri delle tabelle e il loro corrispondente UUID; è richiesto per ripristinare un database danneggiato. Non cancellarlo, è aggiornato ogni volta che c'è una modifica alla struttura.

E' ovviamente il caso di aggiungere questo documento alla lista dei file che saranno automaticamente salvati durante il backup automatico.

La novità che ha richiesto il maggior tempo di sviluppo nella v12 SQL è la possibilità di utilizzare php all'interno di 4D col comando il cui nome provvisorio è PHP Execute.

4D integra (a momento) il motore PHP versione 5.3, ma è possibile anche utilizzare anche un interprete PHP esterno.

Molte delle librerie standard sono già incluse e già utilizzabili (l'elenco delle librerie built-in sarà descritto sul manuale).

Questo permette di passare da sistemi MAMP (Mac, Apache, MySQL e PHP) o WAMP (Windows, Apache, MySQL e PHP) a sistemi M4^DP o W4^D, in cui 4D evita l'installazione e manutenzione di tre componenti.

"io ho la necessità di collegarmi ad un database 4d (che gira su piattaforma Mac) da un server MSSQL per estrarre e pubblicare alcuni dati.
Potete spiegarmi la procedura per poter effettuare questa operazione?"

Risponde Umberto Migliore:
Ci sono diverse possibilità:

• se sul server 4d è presente la licenza web si può preparare una chiamata in GET o POST che ritorni i valori in un formato elaborabile (tipo server REST)
• se è presente la licenza WebService si può fare una chiamata SOAP usando l'indirizzo automatico http://indirizzoserver/4DWSDL
• se si vuole accedere alle tabelle direttamente si può usare una chiamata ODBC dopo aver installato il corrispondente driver ODBC (disponibile gratuitamente)
• via PHP utilizzando il driver PDO_4D incluso nelle ultime release di PHP

Diciamo che dipende dal tipo di informazioni che si vogliono passare, con che frequenza e con che controllo di validità o se servono eventuali elaborazioni a monte.

Le listbox ottengono una nuova funzionalità: quando alcune colonne hanno dei valori ripetuti è possibile scegliere una visualizzazione gerarchica, dove è possibile espandere e collassare le righe raggruppate sotto le stesse voci.

Con la v12 SQL sarà possible costruire dinamicamente i form.

Dinamiche saranno anche le variabili: sarà possibile infatti avere variabili solo col nome la cui visibilità e utilizzo diventa non il processo chiamante bensì il form in quanto tale.

Uno dei comandi più potenti presentati è il comando di Duplicazione degli Oggetti, che dà la possibilità di aggiungere in fase di utilizzo campi ed etichette.

Ovviamente il linguaggio di programmazione mette a disposizione tutti gli strumenti per poter interagire con questo tipo di oggetti, tramite puntatori: sarà possibile ad esempio cambiare il testo delle etichette.. come dire che sono dinamici anche gli oggetti statici!

Con 4D v12 SQL sarà possibile avere un oggetto testo formattato.

Può essere personalizzata dimensione, forma, colore e quant'altro. Il testo è formattabile se si attiva un apposito check nelle proprietà dell'oggetto che lo visualizza a video.

Due nuovi comandi del linguaggio permettono inoltre di ottenere il testo nella versione con i tag html che esplicita gli stili oppure lo stesso testo nella versione pulita dagli stili.

Passando come parametro una stringa in forma esadecimale al seguente metodo, questo restituisce il valore decimale relativo:

C_TEXT($CifraEsadecimale_t;$tutteLeCifre_t;$1;$NumEsadecimale_t)
C_LONGINT($0;$posizione_l)
$0:=0
$tutteLeCifre_t:="0123456789ABCDEF"
$NumEsadecimale_t:=$1
While (Length($NumEsadecimale_t)>0)
          $CifraEsadecimale_t:=Substring($NumEsadecimale_t;0;1)
          $NumEsadecimale_t:=Substring($NumEsadecimale_t;2;Length($NumEsadecimale_t))
          $0:=$0*16
          $posizione_l:=Position($CifraEsadecimale_t;$tutteLeCifre_t)-1
          $0:=$0+$posizione_l
End while

Quando viene eseguito il trigger per l'evento On saving new record, se si usa il comando Record number la v11 SQL restituisce il record number assegnato al record, a differenza della 2004 che restituiva come record number "-3".

Abbiamo già visto in una precedente faq come ottenere il proprio indirizzo ip.

Non è detto però che questo metodo funzioni quando sulla macchina sono installate due schede di rete (tipo ethernet e wireless).

Un interessante approccio al problema è stato proposto da Jeffrey Kain della Orchard Software Corporation; la sua soluzione è:

$Err:=NET_Resolve (Current machine;$ip)

Il comando è fra quelli disponibili nel plugin gratuito 4d Internet Commands.

Quando si decide di rendere fruibile un metodo via web service server è bene creare manualmente il metodo COMPILER_WEB.

Questo metodo (che a differenza degli altri metodi COMPILER non viene creato automaticamente) si occupa in sostanza di dichiarare le variabili che vengono passate come parametro al metodo chiamato dal client web service.

Ciò risulta obbligatorio quando il parametro passato come SOAP input è un array: in tal caso infatti nel metodo COMPILER_WEB l'array viene dichiarato con dimensione 0, ma nel metodo chiamato come web service l'array avrà la dimensione corretta in funzione degli elementi che aveva sul client web.

Per impostare i parametri di stampa in 4D Write si utilizza la funzione WR SET PRINT OPTION.
Gli unici comandi del linguaggio standard che vengono utilizzati in fase di stampa da 4DWrite sono PRINT OPTION VALUES, per conoscere i parametri da passare a WR SET PRINT OPTION in alcune circostanze specifiche (wr paper option, wr paper source option) e SET CURRENT PRINTER per impostare la stampante da usare.
Per conoscere il valore delle impostazioni di stampa di 4D Write si usa la funzione WR GET PRINT OPTION.

Una delle funzioni della v11 che facilmente può sfuggire è il fatto che agli oggetti oltre ad assegnare una variabile è possibile assegnare un'espressione.

Cosa significa? Ad esempio, in una lista l'oggetto potrebbe al posto della variabile contenere [tabella]cognome+" "+[tabella]nome per andare a sostituire i due campi relativi.

Oppure, sempre in una lista l'oggetto potrebbe essere un termometro e si può scrivere qualcosa del genere [tabella]quantità/vTotale".

Per cose più complesse, del tipo in funzione di un valore numerico cambiare una descrizione, si può accoppiare con il comando Choose, anch'esso probabilmente sfuggito ai più; esempio:
Choose(Day number([tabella]giorno);"Dom";"Lun";"Mar";"Mer";"Gio";"Ven";"Sab").

Con la v11 SQL i comandi QUERY BY FORMULA e QUERY SELECTION BY FORMULA richiedono obbligatoriamente come parametro la tabella su cui eseguire la query.

Come già detto, per migliorare le prestazioni questi comandi vengono eseguiti sul Server quando vengono eseguiti da un Client. Inoltre è stato implementato un sistema di ottimizzazione delle QUERY BY FORMULA per migliorarne ulteriormente le prestazioni.

Il comando Find in field della v11 SQL sostituisce il Find index key delle versioni precedenti.

Il comando permette di trovare il numero di record che contengono un certo valore da cercare senza modificare la selezioni corrente.

La differenza più sostanziale, oltre al nome, sta nel fatto che il comando adesso accetta anche campi non indicizzati per la ricerca.

Rispetto alle versioni precedenti, con la v11 SQL non è più necessario che il campo su cui eseguire il comando sia indicizzato.

Se ho un testo molto lungo e voglio tagliarlo su più righe di massimo 80 caratteri, ma tagliate dove c'è un separatore tipo spazio o punteggiatura, si può usare questo codice:

$Pat_T:="(?:[^\\p{C}]{1,72})(?:$|\\p{Z})"
ARRAY TEXT($Fold_aT;0)
$Start_L:=1
$FoundAt_L:=0
$Length_L:=0
$Bool_B:=Match regex($Pat_T;$Buf_T;$Start_L;$FoundAt_L;$Length_L)
While ($Bool_B)
  APPEND TO ARRAY($Fold_aT;Substring($Buf_T;$FoundAt_L;$Length_L))
  $Start_L:=$FoundAt_L+$Length_L
  $Bool_B:=Match regex($Pat_T;$Buf_T;$Start_L;$FoundAt_L;$Length_L)
End while

cfr Use Match regex to fold or split text into strings of a maximum length

Un altro schema per l'uso delle transazioni nell'inserimento o nella modifica di un record:

Metodo del Form di inserimento


Case of
  : (Form Event=On Load)
    START TRANSACTION
    ....

  : (Form Event=On Validate)
    VALIDATE TRANSACTION
    ....

  : (Form Event=On Unload)
    If (In transaction)
      CANCEL TRANSACTION
    End if

End case

Da ricordare che il form event On Unload di default non è attivo per il form e dunque è da attivare manualmente.

Prima della disponibilità dei campi di tipo Blob era usuale registrare nel campo Picture anche dati che non fossero immagini.

Però registrando delle immagini 4D accodava 6 byte con la posizione e la modalità di visualizzazione dell'immagine: durante l'aggiornamento della base dati alla v11, 4D elimina questi 6 byte in fondo ai dati registrati nei campi Picture.

Nel caso in cui non si tratta di immagini questo costituisce sicuramente un problema: per risolverlo basta cambiare il tipo del campo da Picture a Blob.

Schema di base per l'utilizzo delle transazioni nella creazione o modifica di un record.

Metodo del Form di inserimento

Case of
  : (Form Event=On Load)
    START TRANSACTION
    ....

---

Pulsante Annulla

    Case of
           : (Form Event=On Clicked)
           CANCEL TRANSACTION
           CANCEL
      End case

---

Pulsante Conferma

Case of
  : (Form Event=On Clicked)
    ...
    If ($hoFattoTuttiIControlli)
      SAVE RECORD
      VALIDATE TRANSACTION
    Else
      CANCEL TRANSACTION
    End if
    CANCEL
End case

Dalla versione v11 è stato aggiunto un ulteriore parametro al comando CALL WEB SERVICE; la sintassi adesso è:

CALL WEB SERVICE (accessURL; soapAction; methodName; namespace{; complexType{; *}})

L'* finale può essere usato per ottimizzare le chiamate. Quando viene passato, il comando non chiude la connessione usata dal processo alla fine dell'esecuzione. In questo modo la successiva chiamata CALL WEB SERVICE riutilizzera la stessa connessione, finché verrà usato l'* finale.

Il meccanismo accelererà in modo notevole le sequenze di chiamata allo stesso server, soprattutto via Internet, sempre che il Web Server chiamato abbia attivo il "keep-alive".

Se il server non ha l'opzione attiva o se si raggiunge il limite massimo di chiamate nella connessione, 4d si occuperà automaticamente di riaprire una nuova connessione quando serve.

Nella versione 11 è possibile impostare un flag per cui un metodo verrà lanciato in automatico sul server (dove in alcune condizioni le cose sono molto più veloci); il processo resterà in attesa del metodo e ne userà il risultato.

Per ottenere la stessa cosa in 2004 dobbiamo fare in modo che il client attenda la fine del processo sul server per leggere la risposta e la stored invece invece alla fine dell'esecuzione deve prima di chiudersi aspettare che il client abbia la risposta.
Ecco un metodo che si può usare come base di lavoro:

=== SUL CLIENT:
C_BLOB(blob_risposta)
$id:=Execute on server("metodo_suserver";128*1024;"metodo")
nexus_stored("attendi";$id)
  ` ... qui posso usare la risposta



=== SUL SERVER:
nexus_stored("start")
  ` ... qui va il tuo codice che scrive la risposta in un blob, ad esempio
nexus_stored("stop")



=== ECCO IL METODO BASE:
    ` Method nexus_stored
    ` Nexus srl, www.nexusonline.it

Case of
  : ($1="start")  ` === startup del processo
    If (Application type=4D Server )
      C_BOOLEAN(stored_finito;client_letto)
      stored_finito:=False
      client_letto:=False
        C_BLOB(blob_risposta)
        SET BLOB SIZE(blob_risposta;0)
    End if
    
  : ($1="stop")  ` === chiusura processo
    If (Application type=4D Server )
      client_letto:=False
      stored_finito:=True
      $start:=Milliseconds
      While (Not(client_letto) & ((Milliseconds-$start)<30000))
        DELAY PROCESS(Current process;1)
      End while
    End if
    
  : ($1="attendi")  ` === legge la risposta dalla stored e la chiude
    C_BOOLEAN(stored_finito;processo_finito;client_letto)
    C_TEXT(currentProgressStatus)
    $pid:=$2
    processo_finito:=False
    Repeat
      DELAY PROCESS(Current process;10)
      GET PROCESS VARIABLE($pid;stored_finito;processo_finito)
    Until (processo_finito)
    GET PROCESS VARIABLE($pid; blob_risposta; blob_risposta)
    client_letto:=True
    SET PROCESS VARIABLE($pid;client_letto;client_letto)
End case

Come già citato, il file Catalog.xml permette di mantenere durante la conversione da 2004 a v11 gli stessi codic identificativi usati nella base dati.

Il file è generato automaticamente durante la conversione e andrebbe salvato per poter riutilizzare.. Nel caso si fosse perso, per rigenerarlo basta:

- Andare in Design nella struttura già convertita in v11
- Scegliere dal menù File il comando "Export Structure to xml"
- Rinominare il file così creato in Catalog.xml

Per utilizzarlo basta metterlo allo stesso livello della struttura in 2004 da convertire.

Il compilatore di 4D in certi casi ha bisogno di un aiuto per essere guidato nei meandri delle varie opzioni di alcuni comandi. Vediamo un esempio:

Il comando Table può ricevere come parametro sia un puntatore che un numero, restituendo rispettivamente o un numero o un puntatore: ciò significa che se uso

SET FIELD RELATION (Table($x)....)

in modo interprete funziona, ma quando si prova a compilare restituisce errore, perché il compilatore non sa a priori cosa restituisce Table($x).

Come risolvere?

Basterà usare una variabile ben dichiarata e tutto scorre liscio:

$tabella_l:=Table(->[MiaTabella])
SET FIELD RELATION ($tabella_l;.....)

Per modificare lo stato di una relazione è assai utile il comando SET FIELD RELATION, soprattutto quando una relazione non è definita automatica da struttura e invece si vuole che lo diventi temporaneamente. La sintassi del comando è:

SET FIELD RELATION (manyTable | manyField; one; many)

dove
- manyTable è la tabella e in questo caso la modifica varrà per tutte le relazioni che partono dalla tabella;
- oppure manyField è il campo da cui parte la relazione;
- one e many prendono il valore delle seguenti costanti per definire le relazioni uno e molti:
Do not modify (0) non modifica nulla;
Structure configuration (1) prende per la relazione il valore stabilito nella struttura;
Manual (2) rende la relazione manuale;
Automatic (3) la rende automatica.


Un esempio:

SET AUTOMATIC RELATIONS(False;False) `Reset delle relazioni
`Solo le relazioni definite adesso verranno usate
SET FIELD RELATION([Invoices]Cust_IDt;Automatic;Automatic)
SET FIELD RELATION([Invoice_Row]Invoice_ID;Automatic;Automatic)
QR REPORT([Invoices];Char(1);True;True;True)

Ecco di seguito un esempio di codice per PDO_4D che consente l'uso di PHP per l'inserimento di dati, con creazione della tabella.


<?php
$dsn = '4D:host=localhost;charset=UTF-8';
$user = 'test';
$pass = 'test';

// Connection to the 4D SQL server
$db = new PDO_4D($dsn, $user, $pass);

try {
        $db->exec('CREATE TABLE test(id varCHAR(1) NOT NULL, val VARCHAR(10))');
} catch (PDOException $e) {
        die("Errore 4D : " . $e->getMessage());
}
          
$db->exec("INSERT INTO test VALUES('A', 'A')");
$db->exec("INSERT INTO test VALUES('B', 'A')");
$db->exec("INSERT INTO test VALUES('C', 'C')");

$stmt = $db->prepare('SELECT id, val from test');

$stmt->execute();
print_r($stmt->fetchAll());

unset($stmt);
unset($db);
?>




L'ouput risultante sarà:


Array
(
        [0] => Array
           (
           [ID] => A
           [0] => A
           [VAL] => B
           [1] => B
           )

        [1] => Array
           (
           [ID] => C
           [0] => C
           [VAL] => D
           [1] => D
           )

        [2] => Array
           (
           [ID] => E
           [0] => E
           [VAL] => F
           [1] => F
           )

)

Esporta in un file di testo con la descrizione della struttura corrente; include il numero di record, le relazioni con indicazioni se automatiche Molti a Uno o Uno a Molti.

C_LONGINT($TabellaNumero;$tabella;$campo;$lunghezza;$tipo)

$cr:=Char(Carriage return )
$doc:=Create document("")
If (ok=1)
  GET TABLE TITLES($Tabelle_nomi;$Tabelle_numeri)
  SORT ARRAY($Tabelle_nomi;$Tabelle_numeri)
  For ($tabella;1;Size of array($Tabelle_nomi))
    $TabellaNome:=$Tabelle_nomi{$tabella}
    $TabellaNumero:=$Tabelle_numeri{$tabella}
    SEND PACKET($doc;$cr+"TABLE "+$TabellaNome+" ("+String(Records in table(Table($TabellaNumero)->))+")"+$cr)
    For ($campo;1;Count fields($TabellaNumero))
      GET FIELD PROPERTIES($TabellaNumero;$campo;$tipo;$lunghezza)
      Case of
        : (($tipo=Is LongInt ) | ($tipo=Is Integer ))
          $tipo:="Long"
        : ($tipo=Is Real )
          $tipo:="Real"
        : ($tipo=Is Alpha Field )
          $tipo:="Alfa "+String($lunghezza)
        : ($tipo=Is Text )
          $tipo:="Text"
        : ($tipo=Is Boolean )
          $tipo:="Bool"
        : ($tipo=Is Date )
          $tipo:="Date"
        : ($tipo=Is Time )
          $tipo:="Time"
        : ($tipo=Is Picture )
          $tipo:="Pict"
        Else
          $tipo:="blob "+String($tipo)
      End case
      GET RELATION PROPERTIES($TabellaNumero;$campo;$oneT;$oneF;$cf;$autoOne;$autoMany)
      If ($oneT=0)
        $relazione:=""
      Else
        $relazione:="-> ["+Table name($oneT)+"]"+Field name($oneT;$oneF)+(Num($autoOne)*"A1")+" "+(Num($autoOne)*"AM")
      End if
      SEND PACKET($doc;Char(Tab )+$tipo+Char(Tab )+Field name($TabellaNumero;$campo)+Char(Tab )+$relazione+$cr)
      
    End for
  End for
  CLOSE DOCUMENT($doc)
  ALERT("finito")
End if

Usa questo comando per mostrare la finestra standard del sistema operativo di scelta del colore.



Un primo parametro serve a preimpostare un colore nella finestra (il default è il nero), mentre il secondo permette di indicare una stringa come titolo (il default è "Colors")

Il comando TRUNCATE TABLE, ereditato evidentemente dall'SQL Truncate (Table), permette la cancellazione di tutti i record di una tabella in una singola operazione.

Rispetto alla consueta coppia di ALL RECORDS / DELETE SELECTION questo comando è molto più veloce, non esegue i trigger né controlla le relazioni per eventuali integrità referenziali, non aggiorna neanche il LockedSet se trova dei record bloccati.
Semplicemente ritorna ok = 1 se ha avuto effetto, altrimenti si interrompe con ok = 0.

Utile ad esempio per ripulire velocemente una tabella temporanea.

Rispetto alle versioni precedenti, adesso oltre agli operatori (+,/,*..) è possibile modificare un'immagine con il comando Transform Picture.

TRANSFORM PICTURE($immagine;Scale;$larghezza;$altezza)
I parametri $larghezza e $altezza sono il decimale del fattore di scala, ad esempio per dimezzare al 50% si usa lo 0,5

TRANSFORM PICTURE($immagine;Translate;$oriz;$vert)
I parametri sono numero anche negativo di pixel di spostamento.

TRANSFORM PICTURE($immagine;Flip horizontally)
Per ottenere un'immagine speculare orizzontalmente.

TRANSFORM PICTURE($immagine;Flip vertically)
Per ottenere un'immagine speculare verticalmente.

TRANSFORM PICTURE($immagine;Reset)
Per annullare tutte le modifiche di sopra.

Invece, non sono annullabili le seguenti opzioni:

TRANSFORM PICTURE($immagine;Fade to grey scale)
Trasforma l'immagine in scala di grigi.

TRANSFORM PICTURE($immagine;Crop;$x;$y;$larg;$alt;)
Ritaglia l'immagine partendo dalle coordinate x e y per un certo numero di pixel di larghezze e altezza

Al comando Get 4D Folder, già presentato in una una precedente faq, accetta nuovi parametri molto utili per identificare alcune cartelle di lavoro. Ecco l'elenco completo ad oggi:

• Active 4D Folder
• Licenses Folder
• Extras Folder (dalla v11.2 da non usare, meglio la Resource folder)
• 4D Client Database Folder
• Database Folder
• Database Folder Unix Syntax
  (utile su Mac quando si usa il comando Launch external process)
• Current Resources folder
• Logs Folder
• HTML Root Folder

A partire da Windows Vista e quindi su tutte le versioni successive di Windows (ad esempio Windows Server 2008) non è possibile interagire con un applicativo lanciato in modalità servizio (cfr. Service Changes for Windows Vista )

La soluzione (da 4d v11 in poi) è lanciare il Client sulla stessa macchina e usare la finestra di Amministrazione per controllare il server.

Oppure per non usare 4d come servizio è possibile fare in modo che sia lanciato all'avvio in modalità normale seguendo queste istruzioni:

1. impostare il login automatico di un utente

2. creare un file autostart.4DLink
<?xml version="1.0" encoding="UTF-8"?><database_shortcut structure_file="file:///C:/4D/miaApp.4DB" data_file="file:///C:/4D/miaApp.4DD"/>

3. creare un file .bat che lanci il 4d Server e il relativo .4DLink
"C:\4D v11 SQL Release 4 Custom\4D Server\4D Server.exe" "C:\autostart.4Dlink"

Fino alla versione 2004 WR Get text ha ritornato un numero massimo di caratteri pari a 32.000 (vedi ad esempio )
Dalla versione 11, se il database gira in modalità Unicode, il limite è diventato lo stesso delle variabili testo, cioè 2GB.

Avendo la necessità di controllare se una copia di sicurezza di un disco fosse andata a buon fine, ho scritto questo metodo ricorsivo che confronta il contenuto di due differenti percorsi. È scritto con la v11SQL. Ecco il metodo ConfrontoDischi:


If (Count parameters=0)
    $percorso1:=Select folder("Percorso 1")
    If (OK=1)
        $percorso2:=Select folder("Percorso 2")
        If (OK=1)
           ARRAY TEXT(arrFile1;0)
           ARRAY TEXT(arrFile2;0)
           ConfrontoDischi (->arrFile1;$percorso1)
           ConfrontoDischi (->arrFile2;$percorso2)
           For ($i;Size of array(arrFile1);1;-1)
           arrFile1{$i}:=Delete string(arrFile1{$i};1;Length($percorso1))
           End for
           For ($i;Size of array(arrFile2);1;-1)
           arrFile2{$i}:=Delete string(arrFile2{$i};1;Length($percorso2))
           End for
           For ($i;Size of array(arrFile1);1;-1)
           $find:=Find in array(arrFile2;arrFile1{$i})
           If ($find>0)
           DELETE FROM ARRAY(arrFile1;$i)
           DELETE FROM ARRAY(arrFile2;$find)
           End if
           End for
        End if
  End if
Else
    $percorso:=$2
    ARRAY STRING(255;$arrNomiFile;0)
    DOCUMENT LIST($percorso;$arrNomiFile)
    For ($i;1;Size of array($arrNomiFile))
        APPEND TO ARRAY($1->;$percorso+$arrNomiFile{$i})
    End for
    ARRAY STRING(255;$arrNomiFile;0)
    FOLDER LIST($percorso;$arrNomiFile)
    For ($i;1;Size of array($arrNomiFile))
        ConfrontoDischi ($1;$percorso+$arrNomiFile{$i}+"\\")
    End for
End if

Ecco un metodo per esportare i dati di una tabella "Tabella" in formato solo testo, con conversione del set di caratteri in formato Windows:


$vhDocRef:=Open Document("")
If (ok=1)
  $tableptr:=->[Tabella]
  $tablenum:=Table($tableptr->)

  `prima creo la testata con i nomi dei campi
  For ($j;1;Count fields($tableptr))
    GET FIELD PROPERTIES($tablenum;$j;$fieldType;$fieldLength;$indexed;$unique;$invisible)
    $nome:=Field name($tablenum;$j)
    If ($invisible=False)
      SEND PACKET($vhDocRef;Mac to Win($nome))
      SEND PACKET($vhDocRef;Char(Tab))
    End if
  End for
  SEND PACKET($vhDocRef;Char(Carriage return))

  `seleziono tutti i record
  ALL RECORDS($tableptr->)
  ARRAY LONGINT($arrRecNum;0)
  SELECTION TO ARRAY($tableptr->;$arrRecNum)

  `esporto tutto, tranne i campi Invisibili
  For ($i;1;Size of array($arrRecNum))
    GOTO RECORD($tableptr->;$arrRecNum{$i})
    $rigadaesportare:=""
    For ($j;1;Count fields($tableptr))
      GET FIELD PROPERTIES($tablenum;$j;$fieldType;$fieldLength;$indexed;$unique;$invisible)
      If ($invisible=False)
        $pointer:=Field($tablenum;$j)
        $testodaesportare:=""
        Case of
          : (($fieldType=Is Alpha Field ) | ($fieldType=Is Text ))
           $testodaesportare:=$pointer->
           $testodaesportare:=Replace string($testodaesportare; Char(Carriage return);" ")
          : ($fieldType=Is Boolean )
           If ($pointer->)
           $testodaesportare:="Vero"
           Else
           $testodaesportare:="Falso"
           End if
          Else
           $testodaesportare:=String($pointer->)
        End case

        $rigadaesportare:=$rigadaesportare+Mac to Win($testodaesportare)+Char(Tab)
      End if
    End for
    SEND PACKET($vhDocRef;$rigadaesportare;Char(Carriage return))
  End for
  CLOSE DOCUMENT($vhDocRef)
End if