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)

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)

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.

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.

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.

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.

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.

Vediamo come centrare un grafico ottenuto tramite CT Chart arrays.
Ciclando sull'array dei valori troviamo il massimo valore assoluto nell'array. Sia $max questo massimo.
Possiamo quindi scrivere:

$intervallo:=$max/2
CT SET REAL SCALE (Area;$Chart;0;0;0;0;-$max;$max;$intervallo;0,1)

La variabile $intervallo e il valore 0,1 variano ovviamente in base ai valori che si attendono nel grafico.

La funzione QPx_AcqTestProtocol consente la possibilità di utilizzare un certo protocollo di acquisizione fra quelli supportati dal plugin della Escape.
L'uso è:

$error:=QPx_AcqTestProtocol(acqProtocol)

dove acqProtocol può prendere i valori:

qpx_AcqTWAINProtocol che ha valore 1 per il protocollo TWAIN
qpx_AcqPictureTransferProtocol che ha valore 2 per il PTP (Picture Transfer Protocol identifier)
qpx_AcqVideoProtocol che ha valore 4 per l'acquisizione Video.

Se il protocollo è supportato viene ritornata la costante qpx_NoErr, altrimenti, in base all'errore, qpx_couldntGetRequiredComponent o qpx_paramErr.

La funzione

$err:=QPx_AcqGetDeviceList (acqProtocol;arrListaPeriferiche)

permette di conoscere l'elenco delle periferiche utilizzabili col protocollo definito da acqProtocol. I protocolli possibili sono:

• TWAIN Protocol: per il protocollo TWAIN.
• Picture Transfer Protocol: per la cattura immagine su MacOS X e e l'acquisizione immagine su Windows col protocollo PTP.
• Video Protocol: per l'acquisizione video con QuickTime MacOS X e DirectShow su Windows.

Ecco un elenco sommario delle corrispondenze fra i tipi di dati usati da DLL Wizard e i corrispondenti tipi del linguaggio di 4D.


8-bit: (char, BOOL, BYTE, CHAR, UCHAR, BOOLEAN, CCHAR)

E' possibile passare una variabile integer, longint o real ma le più appropriate sono integer e longint. Passando un real viene effettuata la conversione (a scapito della velocità).

16-bit: (short, WORD, UWORD, SHORT, USHORT)

E' possibile passare una variabile integer, longint o real ma la più appropriata è integer. Passando un real viene effettuata la conversione (a scapito della velocità).

32-bit: (long, word, int, void*, DWORD, LONG...)

E' possibile passare una variabile integer, longint o real, ma la più appropriata è longint. Passando un real viene effettuata la conversione (a a scapito della velocità).

string pointers: (char*, LPCSTR, LPSTR, LPCTSTR, LPTSTR...)

E' possibile passare una variabile alpha o text. Se si usa alpha attenzione alla lunghezza (se si dichiara una variabile 4D di lunghezza inferiore rispetto al dato ottenuto dalla DLL, la stringa viene troncata). Per stringhe olte gli 80 caratteri è necessario passare un text (col limite dei 32.000 caratteri). I caratteri vengono convertiti in modalità ANSI prima di essere inviati alla DLL e, alla ricezione, riconvertiti in ASCII Macintosh.

float values (32 bits): (float)

E' possibile passare una variabile integer, longint o real, ma la più appropriata è real. L'uso di altri tipi può comportare sia rallentamenti (per la conversione) che perdita di dati (i real hanno precisione doppia).

double values (64 bits): (double, GLdouble)

E' possibile passare una variabile integer, longint o real, ma la più appropriata è real. L'uso di altri tipi può comportare rallentamenti.

Per chi, come lo scrivente, usa raramente DLL Wizard, ecco un elenco completo dei tipi di dati gestiti (solitamente, usando DLL Wizard, solo i primi due-tre tipi sono visualizzati):

• 8-bit:
  char, BOOL, BYTE, CHAR, UCHAR, BOOLEAN, CCHAR
  
• 16-bit:
  short, WORD, UWORD, SHORT, USHORT
  
• 32-bit:
  long, word, int, short*, word*, long*, int*, void*, DWORD, LONG, LPVOID, UINT, GLOBALHANDLE, HANDLE, HLOCAL, LPDWORD, LPBOOL, LPBYTE, LPWORD, LPLONG
  
• string pointers:
  char*, LPCSTR, LPSTR, LPCTSTR, LPTSTR, NPSTR, PCSTR, PCWSTR, PSTR, PTSTR
  
• double values (64 bits):
  double, GLdouble
• float values (32 bits):
  float
  
• void return:
  void, VOID
  

CT Chart arrays crea un grafico a partire dai dati memorizzati in alcuni array.
La sintassi è:

CT Chart arrays (area; type; size; categoryArray; seriesArray; valuesArray)

dove "area" è l'area 4D Chart, "type" è il tipo di grafico, "size" è la dimensione iniziale del grafico, "categoryArray", "seriesArray", e "valuesArray" sono gli array contenenti x, y e z del nostro grafico.

I tipi di grafico passabili in "type" sono:

1 per il grafico di tipo Area
2 per il grafico di tipo Column
3 per il grafico di tipo Picture
4 per il grafico di tipo Line
5 per il grafico di tipo Scatter
6 per il grafico di tipo Pie
7 per il grafico di tipo Polar
8 per il grafico di tipo 2D XY
100 per il grafico di tipo 3D Column
101 per il grafico di tipo 3D Line
102 per il grafico di tipo 3D Area
103 per il grafico di tipo 3D Surface
104 per il grafico di tipo 3D Triangle
105 per il grafico di tipo 3D Spike

A "size" possono essere assegnati i valori

1 = Variabile
2 = Relativa alla finestra (Auto-Variable)
3 = Relativa al grafico (Auto-Document)

L'array "categoryArray" è l'array delle X
L'array "seriesArray" è l'array delle serie. In un grafico bidimensionale è mostrato nell'asse X, nei tridimensionali è la Y
L'array "valuesArray" è l'array contenente i valori.

CT SET PROPERTIES permette di impostare le proprietà dell'area 4D Chart.

La sintassi è:

CT SET PROPERTIES (area; printOrder; changeAlert; hotlinkType; saveAlert)

dove
- area è l'area di Chart
- printOrder è l'ordine di stampa (non l'orientamento): 0 in orizzontale, 1 in verticale, -1 non modificare
- changeAlert mostra un alert se l'utente prova a modificare l'area
- hotlinkType è un parametro obsoleto, usare come valore -1
- saveAlert per chiedere all'utente il salvataggio dell'area.

Per changeAlert e saveAlert e valori utilizzabili sono: 0 nessun messaggio, 1 avverti, -1 non modificare l'impostazione.

il comando CT MOVE permette di spostare degli oggetti all'interno dell'area di chart. La sibntassi è:

CT MOVE (area; scope; newLeft; newTop)

dove
area è la'area di Chart;
scope indica a quali oggetti applicare il movimento: -1 indica tutti gli oggetti dell'area, 0 indica gli oggetti attualmente selezionati, un altro numero maggiore di 0 indica l'ID dell'oggetto a cui applicare l'azione;
newLeft e newTop sono le nuove coordinate.

Il comando di 4D Chart CT SET CHART COORDINATES permette di impostare la posizione di un grafico all'interno dell'area.
La sintassi è:

CT SET CHART COORDINATES (area; object; left; top; right; bottom)

dove
area è l'area di 4D Chart
object è il grafico creato, ad esempio, con CT Chart arrays
left; top; right; bottom sono le coordinate del grafico (in punti).

CT SET LEGEND TEXT permette di impostare i titoli delle serie (o delle categorie per i grafici a torta, i pie) di un grafico. La sintassi è:

CT SET LEGEND TEXT (area; object; legendItem; legendtext)

dove
area è l'area di 4D Chart
object è il grafico di cui si vogliono impostare i titoli nella legenda
legendItem rappresenta la n-esima serie di cui vogliamo impostare il titolo
legendtext è il testo che verrà usato come titolo.

Si noti che se anche si usa la legenda in modalità reverse (cioé in ordine inverso rispetto a quello di partenza), avendo applicato il comando CT SET LEGEND ATTRIBUTES, legendItem continua a seguire l'ordine originario.

CT SET DISPLAY permette di visualizzare o meno le barre di un'area 4DChart.
La sintassi è:

CT SET DISPLAY (area; item; displayCode)

dove "area" è l'area 4D Chart, "item" è la zona e "displayCode" è la modalità di viasualizzazione

Il valore di "item" può essere:

1 Menu Bar
2 Chart Tools
3 Object Tools
6 Scroll Bars
9 Rulers

Il valore di "displayCode" può essere:

0 = Nascondi
1 = Mostra
2 = Cambia

Il comando WR Get text del plugin 4D Write permette di ottenere testo da un'area (tutta o una parte) di 4D Write.
Se ad esempio voglio importare un paragrafo di un'area Write scriverò il codice:

C_LONGINT($primo_l;$ultimo_l)
$aCapo:=Char(Carriage return )
WR Find (miaArea;$aCapo;0;0;0)
WR GET SELECTION (miaArea;$primo_l;$ultimo_l)
$testoriga:=WR Get text (miaArea;0;$ultimo_l-1)

Il numero massimo di caratteri che il comando ritorna è 32.000.

Già dalla versione 2004, e a maggior ragione con la v11 SQL, il comando WR Get text usa correttamente i caratteri Unicode.

Per avere sempre i plugin disponibili ogni volta che si usa l'applicativo, sia nella versione 2004 che nella v11 è possibile includere la cartella Plugin.

In Windows si mette allo stesso livello dell'eseguibile, mentre su Mac occorre metterlo nel bundle: il modo più semplice è chiedere le informazioni (command-I) sull'applicazione e usare il pannello Plugin con cui è possibile aggiungere o togliere i Plugin.

4D Draw, il plugin di 4th Dimension dedicato al disegno, è destinato a scomparire.

Il plugin non è Universal Binary, e dunque per essere usato il database sotto Macintosh dovrà essere utilizzato con Rosetta.

Il suggerimento di 4D è di usare le nuove funzionalità grafiche SVG incluse nella nuova versione.

Il comando AP Create method (presente già nel 4D Pack) consentiva di creare metodi all'interno di una struttura non compilata. Mancava però la possiibilità di controllare se un metodo con il nome specificato esistesse.

A questa lacuna pone riparo il comando del 4D Pack AP Does method exist che prende come parametro una stringa e restituisce 0 se il metodo non esiste, 1 altrimenti.

Il linguaggio del plugin 4D Write simula le azioni da eseguire su una certa area. E' possibile creare aree "virtuali" chiamate offscreen area che è possibile creare e cancellare in ogni momento.

E interessante notare che, dal punto di vista prestazioni, è molto meglio, quando possibile, cancellare il contenuto di un'area e riutilizzarla piuttosto che cancellarla per poi ricrearla (ad esempio all'interno di un ciclo).

Per effettuare le operazioni di taglia e incolla con 4DWrite si possono seguire due strade.
La prima è quella di usare

WR EXECUTE COMMAND (Temporary;wr cmd cut )

e

WR EXECUTE COMMAND (Temporary;wr cmd paste )

per effettuare le operazioni tramite gli appunti.
L'altra possibilità è usare:

$myTempBlob:=WR Get styled text (Temporary)

e

WR INSERT STYLED TEXT (Temporary;$myTempBlob)

Questo metodo consente il trasferimento del testo con i suoi attributi (colore, stile), eccettuato i nomi degli stili e i dati sui paragrafi (margini, tabulazioni, ecc).

E' possibile ridurre il numero di record restituiti da una query SQL utilizzando la costante ODBC MAX ROWS all'interno del comando ODBC SET OPTION. Ecco un esempio:

ODBC LOGIN("TestODBC";"";"")
SQLStmt:="SELECT * FROM Clienti"
ODBC SET OPTION(ODBC Max Rows ;100)
ODBC EXECUTE(SQLStmt;[Result1]Field1;[Result1]Field2)
ODBC LOAD RECORD(ODBC All Records )

La funzione QPx_SetOption del plugin QPix di Escape permette di modificare alcune della impostazioni di default del plugin.

La sintassi è:

QPx_SetOption(optionName; numericValue; textValue)

dove

- optionName è il nome dell'opzione;
- numericValue è il nuovo valore da assegnare all'opzione (se numerico);
- textValue è il nuovo valore da assegnare all'opzione (se testuale).

Ad esempio "/pdf/gen/thumb-width" e "/pdf/gen/thumb-height" permettono di stabilire la dimensione dell'anteprima del file PDF generato da QPx_CreatePDFFile o QPx_CreatePDFBLOB; oppure "/export/exif-thumb-width" e "/export/exif-thumb-height" controllano la dimensione dell'anteprima generata da QPx_ExportImageFile, QPx_ExportImageFileToBLOB, QPx_ExportPicture, QPx_ExportPictureToBLOB, QPx_ExportAreaImage, QPx_ExportImporterImage, o QPx_ExportImporterImageToBLOB.

Nel plugin QPix di Escape è presente, tra le altre, una funzione che permette di ottenere un file PDF a partire da un'immagine.
La funzione è

QPx_CreatePDFFile(pdfFilePath; sourceImages; optionFlags)

dove

- pdfFilePath è il percorso al file PDF;
- sourceImages è un array di tipo testo contenente, in ogni elemento, il percorso ad uno dei file da inserire nel PDF;
- optionFlags è dato dalla combinazione dei parametri qpx_PDFShowProgress (mostra una progressi dialog, valore esadecimale 0x0001), qpx_PDFInsertAllPages (inserisce nel PDF tutte le pagine, 0x0002) e qpx_PDFCreateThumbnails (genera una miniatura della pagina della dimensione massima di 256x256 come default, ma il valore è modificabile cambiando le impostazioni del plugin con QPx_SetOption).

Ecco un esempio contenente i comandi necessari per eseguire una query su un database utilizzando il plugin OBDC Pro. Si noti che arArrays è un array di puntatori agli array che dovranno ricevere i risultati e $result può gestire i vari errori che il plugin potrebbe ritornare.


C_REAL(connection_ID)
$result:=ODBC_SQLAllocConnect (connection_ID)
valuePtr:=SQL_MODE_READ_ONLY
$result:=ODBC_SQLSetConnectAttr (connection_ID;SQL_ATTR_ACCESS_MODE ;->valuePtr)
$result:=ODBC_SQLConnect (connection_ID;"DatabaseAccess";"";"")
$testoquery:="SELECT...... FROM ...... WHERE ......"
$result:=ODBC_SQLAllocStmt (connection_ID;$statementID)
$result:=ODBC_SQLPrepare ($statementID;$testoquery)
$result:=ODBC_SQLExecute ($statementID)
For ($i;1;Size of array(arArrays))
      $result:=(ODBC_SQLBindCol ($statementID;$i;arArrays{$i}))
End for
While ($result#SQL_NO_DATA)
      $result:=ODBC_SQLFetch ($statementID)
End while
$result:=0
$result:=(ODBC_SQLFreeStmt ($statementID;SQL_CLOSE ))
$result:=(ODBC_SQLFreeStmt ($statementID;SQL_UNBIND ))
$result:=(ODBC_SQLFreeStmt ($statementID;SQL_RESET_PARAMS ))
$result:=ODBC_SQLDisconnect (connection_ID)

Creare un grafico a partire da alcuni dati è davvero agevole. Basta prendere la selezione desiderata, un campo per la "x" vettoriale, un campo per la y, un campo per i valori e utilizzare il comando CT Chart data. Vediamo un esempio:

ALL RECORDS([Table1])
tableNum:=Table(->[Table1])
categoryField:=Field(->[Table1]Field1)
seriesField:=Field(->[Table1]Field2)
valuesField:=Field(->[Table1]Field3)

vChart:=Open external window(50;50;650;600;8;"Grafico Profitti";"_4D Chart")
CT SET DOCUMENT SIZE (vChart;586;766)
$err:=CT Chart data (vChart;2;1;0;0;tableNum;categoryField;seriesField;valuesField)


Il comando CT SET DOCUMENT SIZE è necessario per fare sì che, in caso di stampa del documento, il grafico venga stampato su una sola pagina.
Per i comandi di stampa con 4D Chart vi rimandiamo a questa faq.

4D Open for Java è un insieme di comandi che permette di interrogare un 4D Server via Java: Linux, Unix, Windows, Mac, ecc. sono tutti sistemi che possono dunque interagire con un server 4D.

Ecco, ad esempio, una procedura per effettuare un ordinamento:

opSelection selection = process.AllRecords(table);
selection.mTableNumber = 1;
opFieldArray fieldArray = new opFieldArray(1);
fieldArray.mTargetTable = 1;

fieldArray.mFieldArray[0] = new opField(1,1);
fieldArray.mFieldArray[0].mFieldNumber=1;
fieldArray.mFieldArray[0].mOrdering=GREATER_THAN; // (*)Ascending order
fieldArray.mFieldArray[0].mFieldType=1;

process.OrderBy(fieldArray);

process.RecordsInSelection(selection);
int found = selection.mRecordsInSelection;

opDataArray dataArray[] = new opDataArray[1];
dataArray[0] = new opDataArray(found);
process.SelectionToArray(dataArray,fieldArray);

for(short i=0;i{
System.out.println(dataArray[0].mDataArray[i].mString);
}

Quando si genera un grafico con 4D Chart, il plugin si occupa autonomamente di assegnare i colori alle varie serie.

Se si desidera personalizzare il colore delle serie, si utilizza il comando CT SET CHART FILL ATTRIBUTES (area; object; partType; partSpecifics; pattern; color).

Il comando prende come parametri l'ID dell'area, l'ID dell'oggetto, il tipo di oggetto, la parte specifica dell'oggetto (questi ultimi due parametri sono espressi da costanti specifiche di 4D Chart), il pattern (da 1 a 36, -1 per non variarlo) e il colore (anche qui -1 per non cambiarlo).

Ad esempio, per far diventare verde "solido" il colore della prima serie del grafico $Chart nell'area Area, scriveremo:

$Color:=CT Index to color (10)
CT SET CHART FILL ATTRIBUTES (Area;$Chart;8;100;3;$Color)

In 4D è incluso un plugin, 4D Chart, che non è molto considerato (forse perchè è gratis :) );in realtà oltre a fare i grafici fornisce alcuni strumenti interessanti, ad esempio per la elaborazione di testi o disegni all'interno di una immagine. Ecco un interessante esempio di utilizzo.

Usando una offscreen area di 4D Chart è possibile conoscere larghezza e altezza di una campo testo, anche multilinea.
I parametri passati sono il testo, il carattere, la dimensione, lo stile, il puntatore all'oggetto che deve ricevere la larghezza e il puntatore all'oggetto che deve ricevere l'altezza.

Ecco il metodo:

C_TEXT($Testo_t)
$Testo_t:=$1
C_STRING(255;$TipoCarattere_S)
$TipoCarattere_S:=$2
C_LONGINT($Dimensione_L;$StileTesto_L)
$Dimensione_L:=$3
$StileTesto_L:=$4
C_LONGINT($Larghezza_L;$Altezza_L)
$Larghezza_L:=0
$Altezza_L:=0
If ($Testo_t#"")
    C_LONGINT($NumeroTipoCarattere_L)
    $NumeroTipoCarattere_L:=CT Font number ($TipoCarattere_S)
    If ($NumeroTipoCarattere_L#0)
        C_LONGINT($ChartArea_L; $TestoChart_L)
        $ChartArea_L:=CT New offscreen area
        $TestoChart_L:=CT Draw text ($ChartArea_L;0;0;2048;5;$Testo_t)
        CT SET TEXT ATTRIBUTES ($ChartArea_L;$TestoChart_L;$NumeroTipoCarattere_L;$Dimensione_L;$StileTesto_L;0;0)
        C_LONGINT($sinistra_L;$alto_L;$destra_L;$basso_L)
        CT GET BOUNDARY ($ChartArea_L;$TestoChart_L;$sinistra_L;$alto_L;$destra_L;$basso_L)
        $Larghezza_L:=$destra_L-$sinistra_L `La larghzza viene trovata riducendola
        $Altezza_L:=$basso_L-$alto_L `L’altezza è corretta
        If ($Larghezza_L>0)
           Repeat
           $Larghezza_L:=$Larghezza_L-100
           CT SIZE ($ChartArea_L;$TestoChart_L;$Larghezza_L;$Altezza_L)
           CT GET BOUNDARY ($ChartArea_L;$TestoChart_L;$sinistra_L;$alto_L;$destra_L;$basso_L)
           Until ((($basso_L-$alto_L)>$Altezza_L) | ($Larghezza_L<100))
           $Larghezza_L:=$Larghezza_L+(100*Num(($basso_L-$alto_L)>$Altezza_L))
           Repeat
           $Larghezza_L:=$Larghezza_L-20
           CT SIZE ($ChartArea_L;$TestoChart_L;$Larghezza_L;$Altezza_L)
           CT GET BOUNDARY ($ChartArea_L;$TestoChart_L;$sinistra_L;$alto_L;$destra_L;$basso_L)
           Until ((($basso_L-$alto_L)>$Altezza_L) | ($Larghezza_L<20))
           $Larghezza_L:=$Larghezza_L+(20*Num(($basso_L-$alto_L)>$Altezza_L))
           Repeat
           $Larghezza_L:=$Larghezza_L-1
           CT SIZE ($ChartArea_L;$TestoChart_L;$Larghezza_L;$Altezza_L)
           CT GET BOUNDARY ($ChartArea_L;$TestoChart_L;$sinistra_L;$alto_L;$destra_L;$basso_L)
           Until ((($basso_L-$alto_L)>$Altezza_L) | ($Larghezza_L<1))
           $Larghezza_L:=$Larghezza_L+1
        Else
           `Se il testo supera i 2048 pixel, ritorna 0
        End if
        CT DELETE OFFSCREEN AREA ($ChartArea_L)
    End if
End if
$5->:=$Larghezza_L
$6->:=$ Altezza_L

Fonte: 4DToday - Michel Pourcel

Aprendo una connessione 4D Open ad un database 4D è possibile ottenere un codice di errore -9947; questo errore indica che l'opzione "Autorizza le connessioni via 4D Open" è deselezionata nelle preferenze del database.

E' possibile attivare questa opzione solo da 4th Dimension o 4D Client, ma non direttamente dalla finestra di preferenze di 4D Server.

Quando si lavora con i blob, benché la loro dimensione può arrivare a 2GB, è necessario però controllare di avere memoria libera a sufficienza. Occorre farlo anche quando si utilizzano array prima di caricare una grande quantità di dati, perchè l'operazione potrebbe non andare a buon fine per problemi di spazio.

A questo scopo, prima di fare operazioni di un certo tipo, si può controllare la disponibilità usando questo comando del plugin gratuito 4D Pack:

AP AVAILABLE MEMORY (MemoriaTotale; MemoriaFisica; MemoriaDisponibile; StackDisponibile)

Il comando AP AVAILABLE MEMORY ritorna le informazioni in bytes sulla memoria installata (totale e fisica) e su quella disponibile a 4D del computer corrente. Ritorna anche la quantità di spazio libero nello stack per il processo corrente.

Il driver ODBC per 4D Server converte i tipi di dati 4D in ben precisi tipi di dati SQL secondo il seguente schema:

Alpha SQL_VARCHAR
Text SQL_LONGVARCHAR
Real SQL_DOUBLE
Integer SQL_SMALLINT
Long Integer SQL_INTEGER
Date SQL_DATE
Time SQL_TIME
Boolean SQL_BIT
Picture SQL_LONGVARBINARY
Subtable N/A
BLOB N/A

Questa invece la conversione dei tipi da una fonte ODBC SQL verso 4D Server:

SQL_VARCHAR Alpha
SQL_CHAR Alpha
SQL_LONGVARCHAR Text
SQL_REAL Real
SQL_DOUBLE Real
SQL_DECIMAL Real
SQL_SMALLINT Integer
SQL_TINYINT Integer
SQL_INTEGER Long Integer
SQL_LONGVARBINARY Picture
SQL_DATE Date
SQL_TIMESTAMP Date
SQL_TIME Time
SQL_BIT Boolean

A differenza delle versioni precedenti, in cui era necessario l'uso del plugin apposito per connettersi a database ODBC, con la versione 2004 del tool i comandi basilari per la connessione a data source esterni sono direttamente disponibili nel linguaggio di programmazione.

I comandi ODBC LOGIN e ODBC LOGOUT permettono di accedere (e di disconnettersi) direttamente alle fonti di dati esterne, passando al primo comando solo nome dell'origine dati, user e password.

Se, come con le versioni precedenti, fosse necessario ottenere un ID di connessione (ad esempio per connettersi contemporaneamente a più di una origine dati), bisogna allora utilizzare il plugin 4D ODBC Pro, che opzione a pagamento.

Usando i comandi per la gestione della seriale su 4D è possibile scegliere fra le varie opzioni il protocollo Hardware: questo imposta sia il DTR che il CTS.

Potrebbe esserci qualche raro caso in cui la seriale si aspetta solo il DTR attivo e non il CTS: in questo caso si può usare plug-in Serial Toolkit Pro, distribuito da Deep Sky Technologies.

La funzione STK_HShake permette di impostare il metodo di handshake con queste opzioni:
err := STK_HShake(refNum; handShakeType; xOnChar; xOffChar)

dove il valore di handShakeType può essere:

0 = no handshake
1 = Xon/Xoff
2 = CTS
3 = DTR
4 = CTS/DTR

Nella 2004, 4D presenta un nuovo plugin "4D for ADO" con cui è possibile dialogare e scambiare dati con la maggior parte dei database relazionali sui sistemi Windows.
Ecco un esempio che mostra il collegamento ad un database utilizzando il nuovo plugin ADO attraverso ODBC.
C_TEXT($ConnStr)
C_LONGINT($ConnID_l)

` --- ADO usando ODBC---
$ConnStr:="Driver={nome_driver};"
$ConnStr:=$ConnStr+"Server=server_DNS;"
$ConnStr:=$ConnStr+"Database=nome_database;"
$ConnStr:=$ConnStr+"Uid=utente;"
$ConnStr:=$ConnStr+"Pwd=password"

` Mi collego al database identificato nella stringa preparata come sopra
$ConnID_l:=DBGateway_Connect ("server_DNS";$ConnStr)

`Comando di chiusura della connessione
DBGateway_Close ($ConnID_l)

Dalla versione di 4D 2003, i componenti non-TCP/IP non sono più usati, per cui il comando OP Load Network Component è obsoleto.

L'ID del TCP/IP è 29 su Mac OS e 2 su Windows. Quindi quando viene richiesto un componente in un comando di 4D, bisogna usare direttamente la costante, come nell'esempio:

PLATFORM PROPERTIES($sistema_l)
If($sistema_l<3)
  netCompID:=29 `sono su Mac
Else
  netCompID:=2 `sono su Windows
End if
$error:=OP Select 4D Server (netCompID;$NomeServer;$IDServer;True)

In 4d Odbc 2003 i comandi OC Set login option e OC Get login option permettono di impostare o leggere i parametri di una connessione ad un database ODBC-compatibile. I parametri a disposizione, con il relativo valore della costante, sono:

SQL_ACCESS_MODE 101
SQL_AUTOCOMMIT 102
SQL_LOGIN_TIMEOUT 103
SQL_OPT_TRACE 104
SQL_OPT_TRACEFILE 105
SQL_TRANSLATE_DLL 106
SQL_TRANSLATE_OPTION 107
SQL_TXN_ISOLATION 108
SQL_CURRENT_QUALIFIER 109
SQL_ODBC_CURSORS 110
SQL_QUIET_MODE 111
SQL_PACKET_SIZE 112

Vediamo alcuni dei valori che impostabili/leggibili:

SQL_ACCESS_MODE
0 = Read/Write
1 = Read Only
Imposta il tipo di accesso (lettura scrittura/sola lettura)

SQL_LOGIN_TIMEOUT
Integer
tempo per la disconnessione: se posto a 0 il timeout viene disabilitato

SQL_OPT_TRACE
0 = Trace off
1 = Trace on
abilita/disabilita il trace delle operazioni su un file di log

SQL_OPT_TRACEFILE
File name
Se SQL_OPT_TRACE è 1, il log verrà scritto su questo file (il file di default è SQL.LOG)

SQL_QUERY_TIMEOUT
Integer
0=No timeout
E' il tempo di timeout di esecuzione di una query prima che venga cancellata

Per stampare un'area di un grafico realizzato con 4D Chart si utilizza il comando CT PRINT, che corrisponde esattamente alla scelta della voce di menu "File" - "Print" della finestra/area Chart.

Il comando mostra di default la finestra di richiesta impostazioni per la stampa. Se non si desidera far comparire tale finestra, basta passare come terzo parametro (dopo l'id dell'area e un parametro che indica la posibilità di annullare la stampa) uno "0", che serve appunto a sopprimere la dialog di impostazione stampa.

Il 4D Pack della 2004.1 permette di creare via linguaggio di programmazione le relazioni della struttura. La sintassi del comando AP Create relation è semplice:

AP Create relation (sourceTableNum; sourceFieldNum; destTableNum; destFieldNum)

prende cioè i numeri di tabella e di campo di partenza e di destinazione della relazione. Per le proprietà della relazione bisogna sempre agire dalla finestra delle proprietà della relazione.
Se l'operazione viene portata a termine con successo, la funzione ritorna 0, altrimenti un codice di errore.

Il comando AP Print settings to BLOB del 4D Pack 2004 permette di memorizzare in un BLOB passato come parametro le attuali impostazioni di stampa per 4th Dimension.
Il BLOB memorizza sia i parametri di layout (paper, orientation, scale) che gli altri parametri tipo (number of copies, paper source, ecc.)

Il BLOB non può essere modificato via linguaggio di programmazion, ma va richiamato usando il comando AP BLOB to print settings.

Il comando ritorna 1 se il BLOB è stato correttamente generato, altrimenti 0.

Usando ODBC, Microsoft Excel ritiene che la prima riga del foglio di calcolo contenga i nomi dei campi: quindi, per questo motivo, l'importazione dei dati in 4D effettuata via ODBC non "prende" il primo record. E' importante notare come questo comportamento non sia un errore, ma rientri in realtà nello standard ODBC, per il quale è necessario avere un nome per ogni colonna importata: ciò per evitare qualsiasi problema.

Come soluzione si può pensare di inserire nel foglio di calcolo, prima dell'importazione, una riga di celle vuote: tale riga verrà considerata da ODBC come la riga contenente i nomi delle colonne.
La riga di celle vuote può essere inserita a mano oppure via linguaggio di programmazione usando il plug-in di 4th Dimension DDE Tools.

Finalmente dalla versione 2003.6 e dalla versione 2004.1 sono stati modificati due comandi facenti parte del pacchetto Internet commands, e precisamente il comando 'Ftp_GetDirList' e anche il comando 'Ftp_GetFileInfo'.

La modifica che è stata apportata riguarda la possibilità di avere nei vari array di ritorno del comando FTP_GetDirList (ftp_ID; directory; names; sizes; kinds; modDates; modTimes): Integer il nuovo array 'modTimes': è un vettore di interi lunghi che ritornano il valore dell'ora di modifica dei file espresso in secondi.
Quindi per esempio, se l'ora di modifica è 10:08 (hh:mm) nel vettore moTimes avremo 3600 x (10) + 60 x (8) = 36.480).

Stesso concetto per il comando FTP_GetFileInfo (ftp_ID; hostPath; size; modDate; modTime): Integer che compila il nuovo parametro modTime con l'ora di modifica del singolo files, di tipo time (hh:mm).

Supponiamo di voler eseguire la funzione CIOCCOLATA presente in un database Oracle e di voler ricevere il valore ottenuto in una varaibile 4D. Per fare questo bastano i comandi ODBC, da usare come come segue:

$sqlstmt:="SELECT CIOCCOLATA FROM DUAL"
ODBC LOGIN("data";"nome";"pass")
ODBC EXECUTE($sqlstmt;vlresult)
ODBC LOAD RECORD `il risultato viene caricato in vlresult
ODBC LOGOUT

Se la funzione avesse bisogno di un parametro, potremmo anche passarlo in maniera dinamica:

vlinput:=5
$sqlstmt:="SELECT CIOCCOLATA(:vlinput) FROM DUAL"
ODBC LOGIN("data";"nome";"pass")
ODBC SET PARAMETER(vlinput;ODBC Param In )
ODBC EXECUTE($sqlstmt;vlresult)
ODBC LOAD RECORD
ODBC LOGOUT

Se avete la necessità di connettervi ad un database mySQL, esistono due plugin per 4th Dimension che potrebbero aiutarvi:

- VmySQL 1.0, rilasciato da Rose development e distribuito da e-Node.

- MySQL Plugin di Pluggers Software.

Entrambi supportano mySQL 4.1 e funzionano a partire dalla versione 2003 del sistema di sviluppo. MySQL Plugin sotto Windows lavora anche con le versioni 6.7 e 6.8.

Ci sono fondamentalmente due possibilità per gestire le immagini in 4D. La
prima è quella di usare i comandi del linguaggio standard, la seconda di
usare un plug-in esterno. QPix è il plug-in della Escape per il trattamento delle immagini nei database 4th
Dimension.
Utilizzando la tecnologia di QuickTime, QPix permette, ad esempio:
- di acquisire informazioni su un'immagine;
- caricarla da un file per visualizzarla in un'area QPix oppure in una
variabile o in un campo;
- filtrarla e comprimerla;
- crearne una thumbnail di qualità normale o alta;
- acquisirla da una fonte TWAIN, creando volendo anche dei TIFF multipagina;
- esportarla su file in uno dei formati supportati da QuickTime.

Per vedere in azione alcuni comandi di 4D Open, il plug-in che permette a due programmi 4D (di cui almeno uno 4D Server) di comunicare, facciamo il seguente esempio.

Supponiamo di conoscere il nome della tabella in cui cercare un certo campo ma di non conoscere il nome del campo stesso. L'unica cosa che sappiamo di questo campo è che è l'unico campo boolean della tabella. Vediamo di ottenere la posizione di questo campo nella tabella.

Supponimo che la tabella sia la numero 1. Avremo:

C_LONGINT($File;$ErrCode;$Field)
ARRAY LONGINT(aTypes;0) `tipi
ARRAY LONGINT(aLength;0) `… lunghezza (degli alfanumerici)
ARRAY LONGINT(aIndexes;0) `indicizzato?
ARRAY LONGINT(aInvisible;0) `invisibile?
ARRAY STRING(15;aNames;0) `nomi

$File:=1 `tabella numero 1

$ErrCode:=OP Get field properties (vl_ConnectID;$File;$Invisible;aNames;aTypes;aLength;aIndexes;aInvisible)

For ($i;1;Size of Array(aTypes))
  If (aTypes{$i}=Is Boolean)
    $Field:=$i 'questo è il numero
  End if
End for

Si noti che l'array aTypes è stato dichiarato longint, ma poteva essere string text real o integer. Il comando ritorna il valore corretto in base al tipo di array inserito.

Nella versione 2004.1 di 4D è disponibile con 4D Pack il comando:

AP Add table and fields (tableName; fieldNamesArray; fieldTypesArray; fieldLengthsArray{; listFormTemplate{; detailFormTemplate}})

Il comando è stato fondamentalmente creato per creare "al volo" le strutture. Prende come parametri il nome della tabella (fino a 31 caratteri), un array con i nomi dei campi, un array con i tipi, un array con la lunghezza relativa per i campi alfanumerici, e, opzionalmente, il nome dei template da usare per i layout di output e di input.

4dBackup è un plugin forinito con 4d che di solito si usa in versione client-server. E' possibile però usarlo anche in monoutenza, ma o lo si esegue in ambiente User o occorre comandarlo da procedura. Ecco un esempio di utilizzo:

C_INTEGER ($Progress_i;$Fill_i)
If (BK Begin full backup = 0)
      If (BK Start copy = 0)
           Repeat
              BK GET PROGRESS ($Progress_i; $Fill_i)
              MESSAGE ("Backup in corso: " + String ($Progress_i) + "%")
           Until (BK Get state # 4)
      End if
      BK END BACKUP
End if

Quando si vuole stampare un'area 4D Write si può usare il comando WR PRINT. Tale comando però stampa l'area solo una volta. Per stampare un'area un numero di volte pari al numero di record selezionati di una tabella bisogna usare il comando WR PRINT MERGE.
Inoltre WR PRINT MERGE permette di impostare in maniera parametrica la visualizzazione o meno della dialog di stampa (0 non la mostra, 1 si), visto che la sintassi è:

WR PRINT MERGE (area; tabella; mostra_dialog)

Ecco un esempio su come stampare una copia di una lettera per ogni cliente:

ALL RECORDS (Clienti]) `Tutti i clienti
QUERY ([Lettere];[Lettere]Ref="Spedisci") `Carica un template
Temp:=WR New offscreen area `Crea l'offscreen area
WR PICTURE TO AREA(Temp;[Letters]Doc_) `Il template nella offscreen area
WR PRINT MERGE (Temp;3) `Unisce il template con i dati nella tabella 3
WR DELETE OFFSCREEN AREA (Temp) `Cancella l'offscreen area

Per stampare un'area di 4D Write senza l'intervento dell'utente è necessario utilizzare il comando WR PRINT. Questo comando equivale alla scelta dell'utente di Print dal menu File dell'area.

E' interessante notare, per chi inserisce campi dinamici nelle aree 4D Write, che il comando WR PRINT può stampare sia i valori che i riferimenti, ma questi ultimi non vengono calcolati automaticamente: l'aggiornamento dei valori deve essere forzato prima dell'esecuzione della stampa. Ad esempio:

WR EXECUTE COMMAND (area;wr cmd compute references)
WR PRINT (area; 0;1)

Ecco un metodo che ritorna come risultato un blob contenente il testo formattato presente in un'area 4DWrite. Il risultato del metodo puo essere inserito in un altro documento usando il comando WR INSERT STYLED TEXT.

    ` $1 - L'area 4D Write
    ` $2 - Posizione del primo carattere
    ` $3 - Posizione dell'ultimo carattere
    ` $0 - Blob il testo

C_LONGINT($1;$wrarea)
C_LONGINT($2;$3;$begsel;$endsel)
C_BLOB($0;$StyledTextBlob)

$wrarea:=$1
$begsel:=$2
$endsel:=$3

Case of
: (($begsel>=0) & ($endsel>0))
    If ($begsel<$endsel)
        WR SET FRAME($wrarea;wr text frame )
        WR SET SELECTION($wrarea;$begsel;$endsel)
        $StyledTextBlob:=WR Get styled text($wrarea)
    End if
: (($begsel=-1) & ($endsel=-1)) ` Copy all
    WR SET FRAME ($wrarea;wr text frame )
    WR EXECUTE COMMAND ($wrarea;wr cmd select all )
$StyledTextBlob:=WR Get styled text ($wrarea)

End case

$0:=$StyledTextBlob

La sintassi è:
FTP_GetFileInfo (ftp_ID; hostPath; size; modDate)

Passando come primi due parametri un ID di sessione e il percorso ad un documento, il comando degli IC FTP_GetFileInfo restituisce nella variabile passata come terzo parametro la dimensione del documento e nella variabile passata come quarto parametro del documento la data di modifica. La funzione restituisce un error code.

L'ID della sessione viene ottenuto usando il comando FTP_Login.

Se come percorso viene passato un percorso completo, la Current Working Directory (CWD) della sessione ftp viene modificata con il percorso passato a FTP_GetFileInfo (stesso comportamento di FTP_GetDirList).

Il comando PV SET AREA PROPERTY di 4D View permette di impostare una serie di proprietà dell'area. Ad esempio possiamo usarlo per fare in modo che, cliccando su una cella si selezioni automaticamente l'intera riga:

Case of
      :(Form event=On Load)
          PV SET AREA PROPERTY (area;pv select mode ;pv select single row )
          PV SET AREA PROPERTY (area;pv select highlight ;pv value on )
End case

Usando gli Internet Command è possibile controllare se una macchina è in rete usando il comando NET_Ping. Ovviamente se l'host è protetto attraverso un firewall il comando potrebbe restituire risposta negativa.
Il comando NET_Ping riceve come parametri l'host, un testo da usare come dimensione del pacchetto da inviare, un longint che conterrà lo stato deoll'host e, opzionale, il tempo di timeout. Ecco un esempio di codice per controllare lo stato di un certo host:

`Method: Ping
C_TEXT($1)
C_INTEGER($alive)
$alive:=0
$errcode:=NET_Ping ($1;"test";$alive)
If ($errcode=0)
    If ($alive#1)
           ALERT($1+" non è attivo.")
    Else
           ALERT($1+" è attivo.")
    End if
Else
    ALERT("Errore # "+String($errcode))
End if

Un aspetto molto interessante di 4D è quello di permettere di scrivere delle routine in C o C++ da utilizzare all'interno dei programmi. Queste routine vengono generalmente chiamati plugin.
4D SDK è una raccolta di circa 500 comandi che permettono di integrare il codice scritto in C/C++ con 4th Dimension.

La maniera più rapida per scrivere un plugin è utilizzare 4D plug-in Wizard, un tool di 4D SDK nel quale è possibile definire nomi parametri e valori ritornati dei plugin. Vengono così generati una serie di file che costituiscono il punto di partenza del progetto.

A questo punto possiamo scrivere il nostro codice in C o C++ e quindi compilarlo.
Si piazza il plug-in nella cartella Win4dx o Mac4dx ed ecco che il comando creato in C è tranquillamente utilizzabile dentro 4th Dimension.

Il comando FTP_GetDirList restituisce un elenco di oggetti contenuti in una directory di una sessione ftp identificata da un ftp_ID ottenuto tramite il comando FTP_Login (deve essere ovviamente anche valida, il che si controlla usando FTP_VerifyID). Le informazioni su nome, dimensione, tipo e data di modifica vengono restituite in 4 array. La cartella passata come parametro diventa la cartella corrente della sessione ftp.

Alcuni tipi di immagini possono contenere delle informazioni di tipo "non visuale", che vengono chiamate meta-data o tags. Un tag solitamente è composto di due parti, l'ID e i dati. QPix consente di accedere ai tag TIFF (presenti nei file TIFF e Exif JPEG secondo le specifiche 2.1), Exif (presenti nei file TIFF e Exif JPEG), GPS, IPTC (nei file JPEG, TIFF, and PhotoShop) e QuickTime.

Per ottenere questi dati bisogna intanto estrarre il tag container dall'immagine (è un BLOB) usando il comando QPx_GetImageFileTagContainer. Preso questo BLOB, si usa il comando QPx_OpenTagContainer per ottenere un longint che viene usato come riferimento dai comandi che permettono di estrarre informazioni dai tag, che sono QPx_GetTagInstances, QPx_GetTagInstanceInfo e QPx_GetTagInstanceText: i dati provenienti da tag con un solo elemento vengono memorizzati in variabili di testo, per i tag com più elementi QPix popola un array di testo.
Terminate le operazioni sui tag si usa QPx_CloseTagContainer per liberare la memoria allocata.

Ecco un semplice approccio per ricevere una immagine da un database SQL via ODBC

C_TEXT($sql_t)
C_LONGINT($cursorID_l;$res_l)
C_PICTURE(vPicture_pic)
C_BLOB(vBlob_blb)
$cursorID_l:=OC Create cursor (<>connectID_l)
If ($cursorID_l#-1)
  $sql_t:="select picture from PictureTable where pictureid=123"
  $res_l:=OC Set SQL in Cursor ($cursorID_l;$sql_t)
  If ($res_l=1)
    $res_l:=OC Bind ($cursorID_l;1;"vBlob_blb") ` SQL_BINARY
    $res_l:=OC Execute cursor ($cursorID_l)
    $res_l:=OC Load row ($cursorID_l)
    BLOB TO PICTURE(vBlob_blb;vPicture_pic)
  End if
  OC DROP CURSOR ($cursorID_l)
End if

In questo esempio la variabile vBlob_blb viene legata al campo picture col comando OC Bind. Una volta che il risultato è memorizzato nella variabile BLOB vBlob_blb, il comando BLOB TO PICTURE inserirà l'immagine memorizzata nel BLOB nella variabile di tipo picture vPicture_pic.

Ecco un semplice approccio per inviare una immagine a un database SQL via ODBC

C_TEXT($sql_t)
C_LONGINT($cursorID_l;$res_l)
C_BLOB(vBlob_blb)
PICTURE TO BLOB(vPicture_pic;vBlob_blb;"JPEG")
$cursorID:=OC Create cursor (<>connectID_l)
If ($cursorID_l#-1)
  $sql_t:="insert into PictureTable values (?)"
  $res_l:=OC Set SQL in Cursor ($cursorID;$sql)
  If ($res_l=1)
    $res_l:=OC Bind parameter ($cursorID_l;1;"vBlob_blb";1) ` SQL_BINARY/BLOB
    $res_l:=OC Execute cursor ($cursorID_l)
  End if
  OC DROP CURSOR ($cursorID_l)
End if

In questo esempio il comando OC Bind parameter viene usato per collegare una variabile di tipo picture con un campo di tipo BLOB (SQL_BINARY) nel database ODBC.

In 4D ODBC esistono due comandi che eseguono quasi la stessa operazione (e ovviamente il quasi è rilevante), dove l'operazione in questione è eseguire una query SQL e i due comandi sono OC Query exec e OC Execute SQL.

Entrambi i comandi permettono di mandare una query SQL ad una origine dati e di ottenere i dati in degli array.

La differenza fra i due comandi sta nel tipo di parametri accettati:
OC Query exec può ricevere da 1 a 22 array di dati, e gli array vengono passati come parametri del comando;
OC Execute SQLriceve invece come parametro un unico array di stringhe che contiene la lista degli array che dovranno essere popolati dall'esecuzione della query: questo approccio supera dunque il limite delle 22 colonne del primo comando.

Per creare delle colonne in un documento 4D Write basta andare nel menu Format, scegliere Columns e specificarne il numero. Per eseguire la stessa operazione da linguaggio, si usa il comando:

WR SET DOC PROPERTY (Area_l;$selettore_l;$numcol_l)

Il valore per il selettore "$selettore_l" è quello della costante wr number of columns (24), mentre "Area_l" indica l'ID dell'area 4D Write e "$numcol_l" è il numero di colonne.

4D Write è il plugin 4th Dimension che permettte di avere le funzionalità di un text editor all'interno di un database 4D. Come in ogni text editor, tutte le funzionalità sono accessibili da menu, ma tali funzionalità possono essere gestite anche da linguaggio. Il plugin gestisce documenti di tipo proprietario (4WR7/4W7), file di testo, RTF, HTML e alcuni tipi di file Word.

In un documento di 4DWrite è possiile ovviamente inserire riferimenti diretti a campi del database, per costruire documenti con i dati dei record selezionati e ottenere così un mail merge.

Un'area 4D Write può essere creata o all'interno di un form o in in una external window, con un comando del tipo:

vWrite:=Open external window (50; 50; 350; 450; 8; "Lettera"; "_4D Write" )

E' anche possibile generare una offscreen area (area non visibile) che permette di creare e modificare il documento solo in memoria, con un aumento delle prestazioni: è importante ricordarsi di usare il comando WR DELETE OFFSCREEN AREA per cancellare l'area dalla memoria quando non è più necessaria.

Con la versione 2004 entreranno in scena un maggior controllo delle opzioni di stampa, lo zoom del documento e il dizionario italiano per il controllo ortografico.

I documenti generati da 4D Write sono ovviamente multipiattaforma.

Esistono tre tipi di porte TCP:
- dalla 0 alla 1023: porte che possono essere usate solo da processi di sistema o utenti con privilegi;
- dalla 1024 alla 49151: vengono usate per i processi utente;
- dalla 49152 alla 65535: porte senza alcuna limitazione.

Quindi, per sincronizzare due database attraverso i comandi TCP/IP, devono essere usate porte più alte della 49151.

Ecco un elenco dei numeri di porte TCP standard:

daytime     13     Daytime
qotd     17     Quote of the Day
ftp-data     20     File Transfer [Default Data]
ftp     21     File Transfer [Control]
telnet     23     Telnet
smtp     25     Simple Mail Transfer
time     37     Time
nicname     43     Who Is
domain     53     Domain Name Server
sql*net     66     Oracle SQL*NET
gopher     70     Gopher
finger     79     Finger
http     80     World Wide Web HTTP
poppassd     106     Password Server
rtelnet     107     Remote Telnet Service
pop2     109     Post Office Protocol – Version 2
pop3     110     Post Office Protocol – Version 3
sunrpc     111     SUN Remote Procedure Call
auth     113     Authentication Service
sftp     115     Simple File Transfer Protocol
sqlserv     118     SQL Services
nntp     119     Network News Transfer Protocol
ntp     123     Network Time Protocol
pwdgen     129     Password Generator Protocol
imap2     143     Interactive Mail Access Protocol v2
news     144     NewS
sql-net     150     SQL-NET
multiplex     171     Network Innovations Multiplex
cl/1     172     Network Innovations CL/1
at-rtmp     201     AppleTalk Routing Maintenance
at-nbp     202     AppleTalk Name Binding
at-3     203     AppleTalk Unused
at-echo     204     AppleTalk Echo
at-5     205     AppleTalk Unused
at-zis     206     AppleTalk Zone Information
at-7     207     AppleTalk Unused
at-8     208     AppleTalk Unused
ipx     213     IPX
netware-ip     396     Novell Netware over IP
timbuktu     407     Timbuktu
https     443     Secured protocol
conference     531     chat
netnews     532     readnews
netwall     533     for emergency broadcasts
uucp     540     uucpd
uucp-rlogin     541     uucp-rlogin
whoami     565     whoami
ipcserver     600     Sun IPC server
phonebook     767     phone
accessbuilder     888     AccessBuilder

Un'immagine contenuta in un file del nostro disco può essere letta da QPix con due finalità diverse:

- Da file a variabile 4D: il comando QPx_ReadImageFileInPicture legge un file (il cui percorso è il primo parametro) convertendolo, se contiene un file immagine, in un'immagine QuickDraw che viene memorizzata in una variabile (la variabile è il secondo parametro). La velocità di lettura è commisurata alla dimensione e alle caratteristiche dell'immagine di partenza; inoltre bisogna assicurarsi di aver assegnato a 4D la memoria necessaria all'operazione.

Ecco un esempio:

C_LONGINT($errore_L)
C_TEXT($PercorsoFileImm_T)
C_PICTURE($immagine_P)
  
$PercorsoFileImm_T:="" `così mostra la finestra di scelta file
  
$errore_L:=QPx_ReadImageFileInPicture ($PercorsoFileImm_T;$immagine_P)
  
If ($errore_L#qpx_noErr)
      `si può gestire l'errore:
      `qpx_noErr è una costante che vale 0
      `$errore_L vale 0 se non ci sono errori
      `altrimenti ritorna il codice di errore
End if


- Da file a area QPix: il comando QPx_SetAreaImageFile mostra in un'area QPix (primo parametro) un file immagine di cui deve essere specificato il percorso (secondo parametro).
L'esempio seguente è simile al precedente, eccettuato per la variabile areaQPix_L che contiene il riferimento (un longint) all'area.

C_LONGINT($errore_L)
C_TEXT($PercorsoFileImm_T)

$PercorsoFileImm_T:=""

$errore_L:=QPx_SetAreaImageFile (areaQPix_L;$PercorsoFileImm_T)

If ($errore_L=qpx_noErr)
      `nessun errore
Else
      `errore
End if

QGrid è il plug-in della Escape che permette la visualizzazione di un insieme immagini in un form 4D.
L'approccio è agevole e la possibilità di personalizzazione elevata. Ogni cella può contenere due elementi: l'immagine e il testo, le cui proprietà come posizione e dimensione sono modificabili al livello di pixel; sul testo è possibile inoltre controllare font, colore, allineamento.
È possibile usare uno sfondo personalizzato per le immagini.
QGrid permette di utilizzare il drag and drop degli oggetti, con un completo controllo da parte dello sviluppatore degli eventi.

Se (solo su Windows) trovate una DLL che risolve un vostro problema, potete utilizzarla come se fosse un plug-in generando il codice relativo con DLL wizard.

Tutto avviene molto semplicemente: dovete dare un nome al plugin, dire quale è la DLL di origine, il tipo di dati utilizzato dalla DLL come parametro.

Eseguiti questi passaggi, vengono creati due file da inserire nella cartella win4dx e a questo punto la funzione della DLL scelta è "invocabile" come se fosse un plugin all'interno del vostro software 4th Dimension.

Lo standard ODBC definisce un protocollo di comunicazione che permette ad
una applicazione di interrogare in database attraverso istruzioni SQL. 4D
OBBC fornisce un insieme di comandi che permettono a un database 4D (Mac
e/o Win) di comunicare con un database ODBC. Per comprendere la semplicità
di utilizzo del plugin, basti pensare che servono tre istruzioni per
iniziare a utilizzarlo:
- OC Login dialog per scegliere l'origine dei dati (questo comando
restituisce un ID per la connessione ODBC);
- OC Execute SQL per eseguire una query SQL;
- OC LOGOUT per chiudere la connessione.

Come ogni software di elaborazione testi o foglio di calcolo, anche
4DWrite e 4DView permettono di definire degli stili personalizzati in modo
da uniformare la formattazione del testo. A ogni stile creato dall'utente
viene associato un ID.
Inoltre, in ogni area di 4DView, esistono di default tre stili che è
possibile solo modificare e non cancellare. Gli stili in questione sono:
- lo stile per le celle, il cui ID è -1, che è anche il valore della
relativa costante pv style cells;
- lo stile per l'intestazione di righe e colonne, il cui ID è -2, che è
anche il valore della relativa costante pv style col row headers;
- lo stile per l'intestazione e piè di pagina, il cui ID è -3, che è anche
il valore della relativa costante pv style page footer header.