Delphi Imp2

1- General
Affichage d'un forme de démarrage
begin
Application.Initialize;
Form2 := Tform2.Create(Application);
Form2.Show;
Form2.Update;
Application.Title := 'Marine Adventures Order Entry';
Application.HelpFile := 'MASTAPP.HLP';
Application.CreateForm(TMainForm, MainForm);
Form2.Hide;
Form2.Free;
Application.Run;
Lancer l'application qu'une seule fois
unit instanz_laden;
interface
implementation
uses windows,Dialogs,sysutils;
var mHandle: THandle; // Mutexhandle
Initialization
mHandle := CreateMutex(nil,True,'XYZ');
if GetLastError = ERROR_ALREADY_EXISTS then begin //
L'application est déjà lancée
showMessage(' L''application est déjà lancée !!!!!');
halt;
end;
Faire défiler le titre d'une TForm

var
a:string;
……
procedure TForm1.FormCreate(Sender: TObject);
begin
a:='Look at here !...';
end;
procedure TForm1.Timer1Timer(Sender: TObject);
var i:integer;
begin
application.title:=a;
form1.Caption:=a;
for i:=1 to (length(a)-1) do
a[i]:=application.title[i+1];
a[length(a)]:=application.title[1];
end;
Sélectionne tout le texte de RichEdit
RichEdit1.SelectAll;
Bitmap sur écran
procedure TForm1.Button1Click(Sender: TObject);

var
Bitmap : TBitmap;
begin
Bitmap := TBitmap.create;
Bitmap.LoadFromFile('C:\Program Files\Borland\a.bmp');
canvas.draw(10,10,Bitmap);
end;
Effacer le texte sélectionné

RichEdit1.ClearSelection;
Copier – coller
Memo1.CutToClipboard; Copie le texte sélectionné du contrôle

de saisie dans le Presse-Papiers.
Memo1.CopyToClipboard; Couper le texte sélectionné du contrôle
de saisie dans le Presse-Papiers.
Memo1.PasteFromClipboard; Coller le texte sélectionné du
contrôle de saisie dans le Presse-Papiers
Les messages:
Valeur Signification
mtWarning Une boîte de message
contenant un signe point
d'exclamation jaune.
mtError Une boîte de message
contenant un signe de stop
rouge.
mtInformation Une boîte de message
contenant un "i" bleu.
mtConfirmation Une boîte de message
contenant un point
d'interrogation vert.
mtCustom Une boîte de message ne
contenant pas d'image. Le
titre de la boîte de
dialogue est le nom du
fichier exécutable de
l'application.
Showmessage une boite de message simple.
RadioGroup
procedure TStandardTab.RadioGroup1Click(Sender: TObject);

begin
If RadioGroup1.ItemIndex=0 Then form1.Color:=clSilver;
If RadioGroup1.ItemIndex=1 Then form1.Color:=clBlue;
If RadioGroup1.ItemIndex=2 Then form1.Color:=clYellow;
If RadioGroup1.ItemIndex=3 Then form1.Color:=clRed;
end;
On charge un graphique dans la boîte d'iamge de la fiche

begin
If OpenDialog1.Execute then
begin
Image1.Picture.LoadFromFile(OpenDialog1.FileName);
end;
end;
Select help file:
Application.HelpCommand(HELP_CONTENTS, 0);
Recherche un texte dans Richeedit

begin
FindDialog1.Position := Point(RichEdit1.Left +
RichEdit1.Width, RichEdit1.Top);
FindDialog1.Execute;
end;
procedure TForm1.FindDialog1Find(Sender: TObject);

var
FoundAt: LongInt;
StartPos, ToEnd: Integer;
begin
with RichEdit1 do
begin
{ commence la recherche après la sélection en cours s'il y
en a une }
{ sinon, commence au début du texte }
if SelLength <> 0 then
StartPos := SelStart + SelLength

else
StartPos := 0;
{ ToEnd indique la longueur entre StartPos et la fin du

texte du contrôle éditeur de texte enrichi }
ToEnd := Length(Text) - StartPos;

FoundAt := FindText(FindDialog1.FindText, StartPos, ToEnd,
[stMatchCase]);
if FoundAt <> -1 then
begin
SetFocus;
SelStart := FoundAt;
SelLength := Length(FindDialog1.FindText);
end;
end;
end;
Positionner le pointeur sourie :
Appeler la procédure windows suivante :

SetCursorPos(100,100);
Sortir d'une boucle avec la touche ESC

var
LoopAborted : boolean;
i : integer;
begin
LoopAborted := false;
i := 0;
repeat
// Your Code...
Caption := inttostr(i);
Application.ProcessMessages;
if GetKeyState(VK_Escape) and 128 = 128 then
begin
LoopAborted := true;
break;
end;
inc(i);
until i = 100000;
if LoopAborted then
ShowMessage('User has aborted the loop!');
end;
Dessiner un Bitmap sur l'écran

var
Picture : TPicture;
Desktop : TCanvas;
X, Y : Integer;
begin
Picture := TPicture.Create;
Desktop := TCanvas.Create;
Picture.LoadFromFile('bitmap1.bmp');
Desktop.Handle := GetWindowDC(0);
X := 100;
Y := 100;
Desktop.Draw(X, Y, Picture.Graphic);
ReleaseDC(0, Desktop.Handle);
Picture.Free;
Desktop.Free;
end;
Rendre une Form transparente
Placez un bouton sur Form1 puis ajouter le code suivant:

begin
setwindowlong(form1.handle,gwl_exstyle,(getwindowlong(form1.ha
ndle,gwl_exstyle)
or ws_ex_transparent));
end;
Works on Windows 98/2000
modification du type:
strtofloat(edit1.Text)
strtoint(edit1.text)
inttostr(x) ext…..
Remarque:le type de float c'est extended.
Connaitre la mémoire libre disponible
procedure TForm1.Button1Click (Sender: TObject);

var
Memory : tMemoryStatus;
begin
memory.dwLength := sizeof(memory);
GlobalMemoryStatus(memory);
label1.caption:='memoire totale :
'+inttostr(memory.dwTotalPhys)+' octets';
label2.caption:='memoire libre :
'+inttostr(memory.dwAvailPhys)+' octets';
end;
Faire une capture d'écran

//Copie d'écran de l'ensemble du bureau
Procedure ScreenShot(Bild: TBitMap);
var
c: TCanvas;
r: TRect;
begin
c:= TCanvas.Create;
c.Handle:= GetWindowDC (GetDesktopWindow);
try
r:= Rect(0,0,screen.width,screen.height);
Bild.Width:=screen.Width;
Bild.Height:=screen.Height;
Bild.Canvas.CopyRect(r, c, r);
finally
ReleaseDC(0, c.handle);
c.Free;
end;
end;
//Copie d'écran de la fenêtre active

Procedure ScreenShotActiveWindow(Bild: TBitMap);
var
c: TCanvas;
r, t: TRect;
h: THandle;
begin
c:= TCanvas.Create;
c.Handle:= GetWindowDC (GetDesktopWindow);
h:=GetForeGroundWindow;
if h<>0 then
GetWindowRect(h, t);
try
r:= Rect(0,0,t.Right-t.left,t.Bottom-t.Top);
Bild.Width:=t.Right-t.left;
Bild.Height:=t.Bottom-t.Top;
Bild.Canvas.CopyRect(r, c, t);
finally
ReleaseDC(0, c.handle);
c.Free;
end;
end;

begin
Form1.Visible:=false;
Sleep(750); //fait une petite pause
ScreenShot(Image1.Picture.BitMap);
Form1.Visible:=true;
end;

begin
Form1.Visible:=false;
Sleep(750); //fait une petite pause
ScreenShotActiveWindow(Image1.Picture.BitMap);
Form1.Visible:=true;
end;
Ouvrir/fermer le lecteur de CD
uses mmsystem;
procedure TForm1.Button1Click(Sender: TObject); //Öffnen - Open

begin
mciSendstring('SET CDAUDIO DOOR OPEN WAIT',nil,0,
Self.Handle);
end;
procedure TForm1.Button2Click(Sender: TObject); //Schliessen-

Close
begin
mciSendstring('SET CDAUDIO DOOR CLOSED WAIT',nil,0,
Self.Handle);
end;
Vérifier s'il y a une disquette dans le lecteur
function DiskInDrive(Drive: Char): Boolean;

var
ErrorMode: word;
begin
{ make it upper case }
if Drive in ['a'..'z'] then Dec(Drive, $20);
{ make sure it's a letter }
if not (Drive in ['A'..'Z']) then
raise EConvertError.Create('Not a valid drive ID');
{ turn off critical errors }
ErrorMode := SetErrorMode(SEM_FailCriticalErrors);
try
{ drive 1 = a, 2 = b, 3 = c, etc. }
if DiskSize(Ord(Drive) - $40) = -1 then
Result := False
else
Result := True;
finally
{ restore old error mode }
SetErrorMode(ErrorMode);
end;
end;
begin
if DiskInDrive('a')=false then
begin
ShowMessage('Drive not ready');
end;
end;
Utiliser la fonction Autorun d'un CD
Créer dans le répertoire racine du cd un fichier texte

AUTORUN.INF
Inscrivez les lignes suivantes:
[AutoRun]
OPEN=project1.exe
ICON=icon.ico
Si vous voulez utiliser l'icône du projet, inscrivez
ICON=project1.exe,1
Déplacer un item d'un TListBox Items avec la souris
procedure TForm1.ListBox1MouseMove(Sender: TObject; Shift:

TShiftState; X,Y: Integer);
var
p:TPoint;
begin
p.x:=x;
p.y:=y;
ListBox1.ItemIndex:=ListBox1.ItemAtPos(P,True);
end;
Changer le format de la date

{Valeurs prédéfinies dans Delphi
- DateSeparator
- ShortDateFormat
- LongDateFormat;
- ShortMonthNames;
- LongMonthNames;
- ShortDayNames;
- LongDayNames;}
//change le format de la date

begin
DateSeparator:='.';
ShortDateFormat:='dd.mm.yy';
LongDateFormat:='dddd, dd.mmmm.yyyy';
end;
//donne le nom du jour et du mois

begin
ShowMessage(ShortMonthNames[11]+' - '+LongMonthNames[11]);
ShowMessage(ShortDayNames[5]+' - '+LongDayNames[5]);
end;
Supprimer le beep dans un Tedit quand on appuie sur entrer
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

begin
if Key = Chr(VK_RETURN) then key:= #0;end;
Parcourir d'une image :

If OpenDialog1.Execute then
begin
Image1.Picture.LoadFromFile(OpenDialog1.FileName);
end;
2-Internet :
Vérifier si un string correspond à une adresse Email valide
function IsEMail(EMail: String): Boolean;

var
s: String;
ETpos: Integer;
begin
ETpos:= pos('@', EMail);
if ETpos > 1 then
begin
s:= copy(EMail,ETpos+1,Length(EMail));
if (pos('.', s) > 1) and (pos('.', s) < length(s)) then
Result:= true else Result:= false;
end
else
Result:= false;
end;

begin
if isemail(Edit1.Text) then
begin
ShowMessage('eMail-Adresse!');
end;
end;
Envoyer une-mail
Uses WinTypes, ShellAPI;
begin
ShellExecute( 0, Nil, PChar('mailto:offset@multimania.com'),Nil,
Nil, SW_NORMAL );
end;
Piloter Internet Explorer par OLE

uses comobj;
procedure OpenIE(aURL: string);

var
IE : Variant;
WinHanlde : HWnd;
begin
if (VarIsEmpty(IE) ) then
begin
IE := CreateOleObject('InternetExplorer.Application');
IE.Visible := true;
IE.Navigate(aURL);
end
else
begin
WinHanlde := FindWIndow('IEFrame', nil);
if (0 <> WinHanlde) then
begin
IE.Navigate(aURL);
SetForegroundWindow(WinHanlde);
end
else
ShowMessage('Can''t open IE !');
end;
end;

begin
OpenIE('http://www.Rabee.Net');
end;
Lancer une URL dans le navigateur par défaut

Uses shellapi;
....
procedure TForm1.Label1Click(Sender:TObject);
begin
shellexecute(handle,'open','http://www.Sahab.Net',nil,nil,sw_s
how);
end;
3-Windows :
Lancement de la fenetre proprietes système
rajouter Shellapi dans la clause USES
WinExec('rundll32.exe shell32.dll,Control_RunDLL
sysdm.cpl',SW_SHOWNORMAL);
Connaitre le répertoire temporaire par défaut de windows

var
b: array[0..512] of Char;
begin
GetTempPath(511,b);
label1.caption:=b;
end;
Lancement de la fenetre de config de l'heure

WinExec('rundll32.exe shell32.dll,Control_RunDLL
timedate.cpl',SW_SHOWNORMAL);
Lancer l'économiseur d'écran(écran de veille) :
Appeler la procédure windows suivante :
PostMessage(GetDesktopWindow, WM_SYSCOMMAND, SC_SCREENSAVE, 0);
Afficher les icônes du bureau

Hide desktop icons:
ShowWindow(FindWindow(nil,'Program Manager'),SW_HIDE);
Show desktop icons:

ShowWindow(FindWindow(nil,'Program Manager'),SW_SHOW);
Connaître la résolution de l'écran

var x,y: Integer;
begin
x:=Screen.Width;
y:=Screen.Height;
Label1.Caption:='x-Auflösung: '+IntToStr(x);
Label2.Caption:='y-Auflösung: '+IntToStr(y);
end;
Changer la résolution de l'écran(1)

{Les valeurs de retour pour NewRes sont:
DISP_CHANGE_SUCCESSFUL résolution changée
DISP_CHANGE_RESTART l'ordinateur doit être redémarré
DISP_CHANGE_BADFLAGS Flags incorrecte
DISP_CHANGE_FAILED erreur du driver graphique
DISP_CHANGE_BADMODE résolution non supportée
DISP_CHANGE_NOTUPDATED Windows
NT: La configuration ne peut être écrite dans le registre}
function NewRes(XRes,YRes:DWord):integer;
var
DevMode:TDeviceMode;
begin
EnumDisplaySettings(nil, 0, DevMode);
DevMode.dmFields:=DM_PELSWIDTH or DM_PELSHEIGHT;
DevMode.dmPelsWidth:=XRes;
DevMode.dmPelsHeight:=YRes;
Result:=ChangeDisplaySettings(DevMode, 0);
end;

begin
if NewRes(1024,768)=DISP_CHANGE_SUCCESSFUL then
begin
ShowMessage('Resolution changed.');
end;
end;
Changer la résolution de l'écran sans rebooter(2)
// change la resolution en 640*480

procedure changeres;
var
mode:TDeviceMode;
i:integer;
begin
mode.dmSize := sizeof (MODE);
mode.dmPelsWidth := 640;
mode.dmPelsHeight := 480;
mode.dmBitsPerPel := 16;
mode.dmFields := DM_PELSWIDTH or DM_PELSHEIGHT or
DM_BITSPERPEL;
i := ChangeDisplaySettings(mode, CDS_TEST);
if i=DISP_CHANGE_SUCCESSFUL then ChangeDisplaySettings(mode,
0)
end;
begin
changeres;
end;
4-Base de données :
 Définitions (Aide Delphi):
Base de données :
Collection de données dans des tables.
Requête :
Moyen de rechercher des données dans des tables. Une requête
peut s'appliquer à une ou à plusieurs tables.
Supprime tous les enregistrements de la table

Table1.close;
Table1. EmptyTable;
Table1.open ;
Détermine si un ensemble de données ne contient pas

d'enregistrement.
If table1. IsEmpty then

 Description
Appelez la méthode IsEmpty pour déterminer si un ensemble de
données ne contient pas d'enregistrement. IsEmpty renvoie True
si l'ensemble de données est vide. Sinon, elle renvoie False.
Insertion
begin
table1.Open;
table1.insert;
table1.FieldByName('cfo').AsString:=(edit1.text);
table1.FieldByName('nfo').AsString:=ansiuppercase(edit2.text);
table1.FieldByName('pays').AsString:= ansiuppercase(EDIT8.text);
table1.post;
end;
Recherche:
var
rech:string;
begin
rech :=ansiuppercase ( inputbox('Recherche','Entrer le code
','1'));
If not table1.FindKey([rech]) then
messagedlg('Enregistrement introuvable',mtinformation,[mbok],0);
End;
Recherche par nom (hors le code de la table):
var
rech:string;
x:boolean;
begin
rech:= ansiuppercase (inputbox('Recherche','Entrer le nom de la
fournisseur',''));
table1.First;
x:=false;
while (not table1.Eof) do
if table1.FieldValues ['nfo']=rech then
begin
x:=true;
break;
end
else
table1.next;
if not x then
messagedlg('champ introuvable',mtinformation,[mbok],0);
end;
Suppression: (exemple de confirmation)
Begin
if messagedlg( 'Voulez-vous vraiment supprimer
',mtconfirmation,[mbyes,mbno], 0)=mryes
then
table1.Delete;
end ;
Mot de passe
var
i:integer;
…
begin
I:=0;
End;
…
Begin
if i=3 then
begin
showmessage('Vous-vous étés trompé de mot de passe 3 fois, le
programme va s''arrêter maintenant ..');
form1.Close;
end
else
IF TABLE1.FindKey([edit1.text])
then
begin
form1.hide;
form2.show;
end
else
If messagedlg ('Mot de passe incorect? voulez-vous réessayer
',mtconfirmation,[mbyes,mbno],0)=mryes
then
begin
edit1.clear;
end
else begin
form1.close;
end;
i:=i+1;
end;
Filtre de table (exemple du filtre par la lettre B):
begin
table1.Open;
table1.First;
table1.Filter:='nfo=''B*''';
table1.Filtered:= true;
end;
ignorée le filtre
begin
table1.Open;
table1.First;
table1.Filtered:= false;
end;
----------------------------------------------------------------
var
x:integer;
begin
table1.First;
x:= strtoint(edit1.text);
table1.MoveBy(x-1);
end
Calculer nombre des champs d'une table à partir d'une date

Var
X:integer;
begin
Table1.First;
while not table1.Eof do
begin
if table1.FieldByName('D-DM').AsDateTime>=datetimepicker1.date
then
begin
x:=x+1;
end;
table1.Next;
end;
Edit1.text:=inttostr(x);
End ;
Suppression :( Deuxième exemple .de message box)

Begin
if application.messagebox('vous les-vous supprimer cette
enregistrement',' ', mb_okcancel)=idok then
Table1.delete;
End;
Recherche par 2 edit:

table1.Open;
if not table1.FindKey([edit1.text,edit2.text]) then showmessage
('Enregistrement introuvable);
Enregistrer la modification dans un table :
procedure TFBonSortie.BitBtn1Click(Sender: TObject);

begin
if (Table1.State=DsInsert) or (Table1.State=DsEdit)
then begin
Table1.Post;
end;
end;
Afichage les noms des champs d’un table:

var
i: Integer;
Info: String;
begin
Info := ('Les champs de la table ' + Table1.TableName +
' sont:'#13#10#13#10) ;
for i :=0 to Table1.FieldCount-1 do
Info := Info + Table1.Fields[i].FieldName + #13#10;
ShowMessage(Info);
end;
Suppression dens deux tables:

var
x:string;
begin
x:=dbedit1.Text;
if messagedlg( 'Voulez-vous vraiment supprimer le DMU:
'+dbedit1.Text+' ?',mtconfirmation,[mbyes,mbno], 0)=mryes
then
begin
Table1.Delete;
begin
if table2.FieldByName('n_dmu').AsString=x
then
Table2.Delete
else
Table2.Next;
end;
end;
end;
Annuler la modification dans une table :
procedure TForm4.SpeedButton2Click(Sender: TObject);

begin
table2.Cancel;
end
----------------------------------------------------------------
Procedure TFBonDeCommandeF.DBGrid1KeyPress(Sender: TObject; var

Key: Char);
Begin
If key =#13 then
Begin
dbgrid1.SelectedIndex:=dbgrid1.selectedindex+1;
End;
End;
----------------------------------------------------------------
procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if Key=VK_LEFT then
begin
{ici vous mettez le traitement à faire}
end;
end;
Liste des valeurs possibles pour Key:
VK_LBUTTON : bouton Gauche Souris

VK_RBUTTON : bouton Droite Souris
VK_MBUTTON : bouton Central Souris
VK_CANCEL : Arrêt Exec. programme
VK_BACK : Retour Arrière
VK_TAB : Tabulation
VK_RETURN : Entrée
VK_SHIFT : Touche de contrôle MAJ
VK_CONTROL : Touche de contrôle CTRL
VK_MENU : Touche de contrôle ALT
VK_PAUSE : Pause
VK_ESCAPE : Echappement
VK_SPACE : Barre d'espacement
VK_PRIOR : Page Haut
VK_NEXT : Page Bas
VK_END : Fin
VK_HOME : Début
VK_LEFT : Flèche gauche
VK_UP : Flèche haut
VK_RIGHT : Flèche droite
VK_DOWN : Flèche bas
VK_SNAPSHOT : Impression d'écran
VK_INSERT : Insérer
VK_DELETE : Supprimer
VK_HELP : Aide
VK_NUMPAD0..VK_NUMPAD9 : Touche pavé numérique 0 à 9
VK_MULTIPLY : Touche pavé numérique *
VK_ADD : Touche pavé numérique +
VK_SEPARATOR : Touche pavé numérique Entrée
VK_SUBTRACT : Touche pavé numérique -
VK_DECIMAL : Touche pavé numérique. (Décimal)
VK_DIVIDE : Touche pavé numérique /
VK_F1..VK_F12 : Touches de fonction F1 à F12
VK_NUMLOCK : Verrouillage pavé numérique
VK_SCROLL : Verrouillage scrolling
VK_CAPITAL : Verrouillage majuscules
----------------------------------------------------------------
procedure form1.Button1Click(Sender: TObject );

Begin
If Length (edit1.Text) = 0 then
ShowMessage (’Entrez votre nom.’)
else
begin
ShowMessage (’Hello,’ + s +’!’);
Edit1.Text := ’’;
end;
end;
----------------------------------------------------------------

begin
Series1.Clear; {Où Series1 EST votre BarSeries}
Series1.Add( 25 , 'BMW' , clTeeColor );
Series1.Add ( 50 , 'VW' , clTeeColor );
Series1.Add( 30 , 'Ren' , clTeeColor );
Series1.Add( 50 , 'Peg' , clTeeColor );
Series1.Add( 40 , 'Fiat' , clTeeColor );
Series1.Add( 35 , 'Ford' , clTeeColor );
end;
----------------------------------------------------------------
begin
if key=#13 then edit2.SetFocus;
end;
----------------------------------------------------------------
ComboBox1.DroppedDown := not ComboBox1.DroppedDown;

----------------------------------------------------------------
if SaveDialog1.Execute then
Begin
NewImage.Picture.SaveToFile(SaveDialog1.FileName);
End;
----------------------------------------------------------------
procedure TForm1.Label1MouseMove(Sender: TObject; Shift:
TShiftState; X,
Y: Integer);
Begin
label1.color:=clred;
End;
…
procedure TForm1.Label1MouseLeave(Sender: TObject);
Begin
label1.color:=clbtnface;
End;
----------------------------------------------------------------
begin
Label1.caption:=TimeToStr(Time);
end;
----------------------------------------------------------------

begin
label1.caption:= datetostr(date);
end;
----------------------------------------------------------------
begin
Canvas.TextOut(20, 20, 'Avec Delphi 6, la programmation Windows
n''a jamais été aussi facile');
end;
----------------------------------------------------------------

begin
Canvas.Pen.Color := clBlue;
Canvas.MoveTo( 20, 20 );
Canvas.LineTo( 100, 300 );
Canvas.Brush.Color := clBtnFace;
Canvas.Font.Name := 'Arial';
Canvas.TextOut( Canvas.PenPos.x, Canvas.PenPos.y,'Fin de la
ligne');
End
----------------------------------------------------------------
const
MotDePasse = 'amine';
var
Reponse: string;
DonneReponse: boolean;
begin
Reponse := '';
DonneReponse := InputQuery('Attention', 'Entrez le mot de
passe', Reponse);
if not DonneReponse then
ShowMessage('Vous deviez indiquer un mot de passe !');
if DonneReponse and (Reponse = MotDePasse) then
ShowMessage('Mot de passe correct');
if DonneReponse and (Reponse <> MotDePasse) then
ShowMessage('Mot de passe incorrect');
End;
----------------------------------------------------------------

begin
With Series1 do
Begin
Add( StrToInt(Edit1.Text), 'Data1' , clRed ) ;
Add( StrToInt(Edit2.Text), 'Data2', clBlue ) ;
Add( StrToInt(Edit3.Text), 'Data3', clGreen ) ;
end;
end;
----------------------------------------------------------------
RichEdit1.Clear;
NomFichier := 'Sans titre.txt';
StatusBar1.Panels[0].Text := NomFichier;
----------------------------------------------------------------
var
x:integer;
begin
for x:=4 to 2000 do
memo1.Lines.Add(inttostr(x));
end;
----------------------------------------------------------------
1) Application.ShowMainForm := False;  Pour masquer la fiche
principale au démarrage.
2) Form1.Caption:=Application. Title;
----------------------------------------------------------------
Application.Terminate; //Fin de programme
----------------------------------------------------------------
if OpenDialog1.Execute then
begin
MediaPlayer1.FileName := OpenDialog1.FileName;
MediaPlayer1.Open;
MediaPlayer1.Display := Form1;
MediaPlayer1.DisplayRect := RECT(10,10,200,200);
end;
----------------------------------------------------------------
06-Question
Comment écrire dans un caption sur plusieurs lignes (16/05/99)

Utilisez le caracrère #13 (retour chariot) :
Label1.Caption:='première ligne'+#13+'deuxième ligne';
Comment indenter plusieurs lignes à la fois (09/11/97)
Comment passer de
begin begin
if X >0 then x=0; if X >0 then x=0;
if X<0 then x=-1; A if X<0 then x=-1;
A:=truc+machintruc; A:=truc+machintruc;
end; end;
Sans le faire ligne par ligne ?
Sélectionnez les lignes puis faire Ctrl+Maj+i pour déplacer les
lignes vers la droite ou Ctrl+Maj+u pour les déplacer vers la
gauche.
Dans un TEdit : comment empêcher l'entrée de certaine touches,

par exemple n'autoriser que les valeurs numériques? (30/12/98)
Tout simplement en créant une réponse à l'événement OnKeyPressed

du TEdit faisant croire que les touches non souhaitées ont la
valeur #0 :
begin
if  (1)
not (key in [#8,'0'..'9',DecimalSeparator,'+','-']) then
key:=#0;
end;
(1): DECIMALSEPARATOR Caractère utilisé pour séparer la

partie décimale et la partie entière d'un nombre (par exemple,
une virgule dans 3,14). Valeur par défaut : le séparateur
décimal sélectionné pour votre pays dans le Panneau de
configuration de Windows (Paramètres régionaux.)
Les propriétés :
Exemple :
Flat: Détermine si les boutons ont un aspect tridimensionnel
avec des bordures ou un aspect bidimensionnel sans bordure.
----------------------------------------------------------------
ShowAccelChar
Label1.ShowAccelChar := False;
Label1.Caption := 'Une esperluète & apparaît ici';
 Le résultat : 'Une esperluète & apparaît ici
Label1.ShowAccelChar := False;
Label1.Caption := 'Une esperluète & apparaît ici';
 Le résultat : 'Une esperluète apparaît ici
Tag:Stocke une valeur entière dans un composant.
TopIndex: pour ListBox,Spécifie l'indice de l'élément
apparaissant en haut de la boîte liste.
Modification d'un menu Form1.Menu := SecondMenu;
procedure Abort; virtual;

Description
La méthode Abort annule l'opération en cours. Cette méthode est
surchargée dans les classes dérivées, car chaque protocole a
des besoins particuliers pour annuler une opération.
Exp: for I := 1 to 10 do { boucler dix fois }
begin
ListBox1.Items.Add(IntToStr(I)); { ajouter un nombre à la
liste }
if I = 7 then Abort; { arrêter au septième }
07-RACCOURCIS DELPHI
Placez votre curseur sur une ligne vierge de votre programme et

faite ctrl j. Delphi vous propose :
Ctrl+Espace Dans l'éditeur : complète le mot sur

le quelle se trouve le curseur en
listant les possibilités de variables
et autres
Ctrl+Maj Pour afficher la syntaxe des méthodes :
+Espace
if trim(dbedit6.text)='' then
begin
codeEstSaisie:=false;
Showmessage('Le Code Doit avoir une valeur');
Intervalle de table

begin
with Table1 do
begin
{ Définit la clé de début }
EditRangeStart;
IndexFields[0].AsString := edit1.text;
{ Inclut 1351 dans l'intervalle. }
{ KeyExclusive s'applique au début de l'intervalle }
{ en raison de l'appel à EditRangeStart }
KeyExclusive := False;
{ Définit la clé de fin }
EditRangeEnd;
IndexFields[0].AsString := edit2.text;
{ Exclut 1356 de l'intervalle }
{ KeyExclusive s'applique maintenant à la fin de l'intervalle

}
{ en raison de l'appel à EditRangeEnd }
KeyExclusive := True;
{ Indique à la table d'appliquer l'intervalle }
ApplyRange;
end;
end;
----------------------------------------------------------------
with Customer do
begin
EditRangeStart;
FieldByName('Company').AsString := Edit1.Text;
{Définit l'intervalle de début en fonction du texte du
composant Edit1 }
EditRangeEnd;
FieldByName('Company').AsString := Edit2.Text;
{Définit l'intervalle de fin en fonction de la valeur du

composant Edit2 }
ApplyRange; {Applique les intervalles }
end;
----------------------------------------------------------------
function IsEmpty: Boolean;
Détermine si un ensemble de données ne contient pas
d'enregistrement.
Description
Appelez la méthode IsEmpty pour déterminer si un ensemble de
données ne contient pas d'enregistrement. IsEmpty renvoie True
si l'ensemble de données est vide. Sinon, elle renvoie False.
Exp :if table1. IsEmpty then ….
----------------------------------------------------------------
property AfterScroll: TDataSetNotifyEvent;
Se produit quand une application est passée d'un enregistrement
à un autre.
Description
Ecrivez un gestionnaire d'événement AfterScroll pour effectuer
des actions spécifiques quand une application vient de passer à
un autre enregistrement à la suite de l'appel des méthodes
First, Last, MoveBy, Next, Prior, FindKey, FindFirst, FindNext,
FindLast, FindPrior ou Locate. AfterScroll est appelé après tous
les autres événements déclenchés par ces méthodes qui font
passer à un autre enregistrement de l'ensemble de données.
----------------------------------------------------------------
procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose:
Boolean);
begin
if MessageDlg('Fermer la fiche ?', mtConfirmation,
[mbOk, mbCancel], 0) = mrCancel then
CanClose := False; // Ne va à FormClose que si CanClose est
à true
//C'est FormClose qui déclenchera la fermeture de
l'application
end;
----------------------------------------------------------------
property Bof: Boolean;
Indique si une requête est positionnée au début de l'ensemble de
données.
Utilisez la propriété BOF pour déterminer si une requête est
positionnée au début de l'ensemble de données.
----------------------------------------------------------------
Le code suivant affiche une boîte de dialogue si le travail
d'impression a été abandonné :
if Printer.Aborted then
MessageDlg('Le travail d''impression n''a pas terminé
l''impression', mtInformation, [mbOK], 0);
----------------------------------------------------------------
property HintPause: Integer;
Spécifie l'intervalle de temps qui s'écoule avant que
n'apparaisse le conseil du contrôle quand l'utilisateur a placé
le curseur de la souris au-dessus du contrôle ou de l'élément de
menu
Description :
Utilisez HintPause pour modifier la durée par défaut de 500 ms
ou 1/2 seconde, définie dans le constructeur. Lors de
l'affectation d'une valeur à HintPause l'intervalle doit être
exprimé en millisecondes. Le conseil affiché à la fin de
l'intervalle est spécifié dans la propriété Hint
Exp :
procedure TForm1.FormActivate(Sender: TObject);
var i:integer;
begin
application.HintPause:=0;
end;
----------------------------------------------------------------
procedure TForm1.Panel2MouseMove(Sender: TObject; Shift:
TShiftState; X,
Y: Integer);
begin
{Si on bouge la souris avec la touche gauche appuyée (ssLeft)
alors on redimensionne
le Panel1. Le Panel3 qui est Align=alClient suivra
automatiquement}
if ssLeft in Shift then Panel1.Width:=Panel1.Width+X;
end;
----------------------------------------------------------------
begin
Memo2.Parent:=Panel1;
end;
----------------------------------------------------------------
begin
MessageBeep(MB_ICONASTERISK);
showmessage('R2514487');
end;
Autre :
MessageBeep(MB_OK);
MessageBeep(MB_ICONHAND);
MessageBeep(MB_ICONQUESTION);
MessageBeep($FFFFFFFF) ;
----
dbcdt.Histor_equip.Filter:='repere='+Quotedstr(edit1.text);
table5.Filter:=('craft ='''+edit2.Text+'''');
----------------------------------------------------------------
begin
DateSeparator := '-';
ShortDateFormat := 'm/d/yyyy';
Label1.Caption := DateToStr(Date);
end;
----------------------------------------------------------------
Trim :Fonction
supprime les caractères de contrôle et les espaces se trouvant
en début et en fin de chaîne.
Exp: if length(trim(Edit1.text))=16 then showmessage(‘ Hallo ‘);
----------------------------------------------------------------
var
Form1: TForm1;
i: Byte;
…

begin
i:=0;
//AlphaBlend:=True; AlphaBlendValue:=0; (cf. Inspecteur
d'objets|Form1)
end;
begin
Inc(i);
with Form1 do begin
if AlphaBlendValue<255
then AlphaBlendValue:=i
else Timer1.Enabled:=False
end;
end;
----------------------------------------------------------------
const crMyCursor = 5;
crAutreCurseur = 6;

begin
{-----------utilisation d'un curseur prédéfini dans Delphi----
----}
Edit1.Cursor:=crCross;// on peut aussi directement l'affecter
dans l'inspecteur d'objets
{-----------utilisation d'un curseur perso-----------}

Screen.Cursors[crMyCursor] :=
LoadCursorFromFile('showcur.cur');
Screen.Cursors[crAutreCurseur] :=
LoadCursorFromFile('AutreCur.cur');
//Screen.Cursors[]contient les Handles des curseurs
utilisables dans l'application.
//LoadCursorFromFile charge un curseur en mémoire et renvoie
son Handle
Memo1.Cursor:=crAutreCurseur;// changement du ceurseur pour le
mémo
Button1.Cursor:=crAutreCurseur; // changement du curseur pour
le bouton
end;
----------------------------------------------------------------
Memo1.Undo; annuler les modifications dans zone de texte.
----------------------------------------------------------------
procedure TForm1.DBGrid1DrawColumnCell(Sender: TObject;
const Rect: TRect; DataCol: Integer; Column: TColumn;
State: TGridDrawState);
begin
// red font color if length > 100
if (Column.Field =Table1prix) and (Table1prix.AsInteger >=
100) then
DBGrid1.Canvas.Font.Color := clRed;
// default drawing
DBGrid1.DefaultDrawDataCell (Rect, Column.Field, State);
end;
Afficher les images dans un DBGrid
procedure TForm1.DBGrid1DrawColumnCell(Sender: TObject; const

Rect: TRect;
DataCol: Integer; Column: TColumn; State: TGridDrawState);
var
Picture: TPicture;
OutRect: TRect;
PictWidth: Integer;
begin
// default output rectangle
OutRect := Rect;
if Column.Field = table1NOM then

begin
// draw the image
Picture := TPicture.Create;
try
Picture.Assign(table1Image);
PictWidth := (Rect.Bottom - Rect.Top) * 2;
OutRect.Right := Rect.Left + PictWidth;
DBGrid1.Canvas.StretchDraw (OutRect, Picture.Graphic);
finally
Picture.Free;
end;
// reset output rectangle, leaving space for the graphic
OutRect := Rect;
OutRect.Left := OutRect.Left + PictWidth;
end;
// red font color if length > 100 (omitted — see above)
// default drawing
DBGrid1.DefaultDrawDataCell (OutRect, Column.Field, State);
End;
----------------------------------------------------------------
Label1.wordWrap :=true ;
Description
nitialisez WordWrap à True pour permettre au libellé d'afficher
plusieurs lignes de texte. Quand WordWrap est à True, tout texte
trop long pour la largeur du contrôle libellé passe à la ligne
suivante au niveau de la marge droite et continue sur les lignes
suivantes.
Initialisez WordWrap à False pour limiter le libellé à une seule

ligne. Quand WordWrap est à False, tout texte trop long pour le
libellé est tronqué.
----------------------------------------------------------------
Inc(valeur)  Incrémente une valeur ordinale (X) de 1 ou de N.
Exemple :
var
IntVar: Integer;
LongintVar: Longint;
begin
Inc(IntVar); { IntVar := IntVar + 1 }
Inc(LongintVar, 5); { LongintVar := LongintVar + 5 }
end;
----------------------------------------------------------------
procedure TFOT2date.SpeedButton1Click(Sender: TObject);
var
debut,fin:tdate;
begin
debut:=strtodate(edit1.Text);
fin:=strtodate(edit2.text);
Query1.Close;
Query1.SQL.Clear;
Query1.SQL.Add('SELECT * FROM Ot where date_ot>=:date_d and
date_ot<=:date_f');
Query1.ParamByName('date_d').asdate:=debut;
Query1.ParamByName('Date_f').asdate:=fin;
Query1.open;
end;
----------------------------------------------------------------
Halt :Exécute une fin anormale d'un programme.
Description :
La procédure Halt exécute une fin anormale d'un programme et
renvoie le contrôle au système d'exploitation. Pour exécuter une
fin normale d'une application non-console VCL Delphi, appelez
Application.Terminate. Exitcode est une expression facultative
qui indique le code de sortie du programme.
------
Déplasment de la fiche par fléche....
begin
case Key of
vk_UP : Self.Top := Self.Top - 10;
vk_DOWN : Self.Top := Self.Top + 10;
vk_LEFT : Self.Left := Self.Left - 10;
vk_RIGHT : Self.Left := Self.Left + 10;
end;
Piloter Excel par OLE
uses ComObj;
…
var
excel:Variant;
i:Byte;
begin
try
excel:=CreateOleObject('Excel.Application');
except
ShowMessage('Excel n''a pas pu être lancé !');
exit;
end;
excel.Visible:=true;
table1.First;
i:=1;
excel.Workbooks.Add;
begin
excel.Cells[i,1].Value:=Table1code.Value;
excel.Cells[i,2].Value:=Table1designation.Value ;
excel.Cells[i,3].Value:=Table1Quentit.Value ;
table1.Next;
i:=i+1;
end;
end;
Créer des fenêtres rondes

procedure TForm1.FormCreate(Sender:TObject);
var
region: HRgn;
begin
region:=CreateEllipticRgn(1,1,200,200);
SetWindowRgn(handle, region, true);
end;
Créer un dégradé sur une TForm
procedure TForm1.FormPaint(Sender: TObject);
var Row, Ht: Word; IX: Integer;
begin
iX :=200 ;
Ht:=(ClientHeight + 512) div 256;
for Row := 0 to 512 do
begin
with Canvas do begin
Brush.Color := RGB(Ix,0,row);
FillRect(Rect(0, Row * Ht, ClientWidth, (Row + 1) * Ht));
IX :=(IX-1); end; end;
end;
Lancement de calculatrice :

begin
WinExec('Calc',SW_SHOWNORMAL);
end;
Comment exécuter une application extérieure ?
Pour exécuter une application extérieure au programme il suffit

d'utiliser la fonction suivante de l'API:
function ShellExecute(hWnd: HWND; Operation, FileName,

Parameters,
Directory: PChar; ShowCmd: Integer): HINST; stdcall;
Il faut ajouter l'unité ShellApi dans la clause uses de l'unité

contenant la fonction. Par exemple :
uses [...], ShellApi;
Tous les paramètres chaînes doivent être des PAnsiChar ou PChar.
Rappel : Pour les versions 1 à 4 de Delphi, Il faut toujours

transtyper explicitement les chaînes constantes:
ShellExecute(0,PChar('open)...,)'
A partir de Delphi 5, le transtypage est inutile :

ShellExecute(0,'open)...,'
Détail des paramétres :

hwnd : est le Handle de la fenêtre qui servira de parent pour
les messagesbox de l'application. Toujours passer
Application.Handle en cas de doute, 0 sinon .
Operation : Type d'opération effectuée sur le fichier, a moins
de savoir ce que l'on fait, passer 'open.'
Ce paramètre peut prendre les valeurs suivantes:
'OPEN' ouvrir un document, ou exécuter une application
'PRINT' pour imprimer un document
'EXPLORE' pour utiliser l'explorateur Windows en utilisant le
chemin donné par FileName
'FIND' pour appeler la fenêtre de recherche en utilisant le
chemin donné par FileName
FileName : Nom de l'application à lancer, du document à

ouvrir/imprimer, du répertoire à explorer, etc. Chemin complet
requis, sauf si Directory est correctement renseigné .
Parameters :
Liste des paramètres dans le cas ou FileName désigne une
application. Pour un document ou dans le cas où il n'y a pas de
paramètres, mettre Nil
Directory : Répertoire par défaut utilisé dans le cas où
FileName désigne une application. Correspond en général au
chemin de l'élément exécuté, ou nil si le chemin est absolu ou
si le chemin de démarrage n'a pas d'importance .
ShowCmd : Décrit comment la nouvelle fenêtre doit être ouverte.
Les plus utiles sont SW_SHOW pour afficher l'élément exécuté,
SW_SHOWMINIMIZED pour l'exécuter en fenêtre réduite et SW_HIDE
pour cacher la fenêtre d'exécution. Voir l'aide en ligne pour
plus d'informations .
Quelques exemples d'utilisations :
Lancer une application simplement :
ShellExecute(0,'OPEN','Wordpad.exe', Nil, Nil, SW_SHOW;)
Lancer une application avec des paramètres :

ShellExecute(0,'OPEN','Wordpad.exe','C:\temp\essai.txt',Nil,
SW_SHOW;)
//Exécution de la commande système "ipconfig /all"

ShellExecute(Application.Handle,'open','ipconfig','/all',nil,SW_
SHOW;)
Lancer l'explorateur sur un répertoire précis :

ShellExecute(0,'EXPLORE','C:\MonRépertoire\', Nil, Nil,
SW_SHOW;)
Ouvrir un document :
ShellExecute(0,'OPEN','C:\Temp\Monfichier.txt', Nil, Nil,
SW_SHOW;)
Imprimer un document :
ShellExecute(0,'PRINT','C:\Temp\Monfichier.doc', Nil, Nil,
SW_SHOW;)
Appeler la fenêtre de recherche de Windows :

ShellExecute(Application.handle, 'find', 'c:\temp', Nil, Nil,
SW_SHOWNORMAL;)
Exécuter un fichier Batch:
Pour exécuter un fichier Batch, il faut passer le nom du fichier

à l'interpréteur de commande. Pour ceci, le paramètre FileName
doit être égal à PChar(GetEnvironmentVariable('ComSpec')), et le
paramètre Parameters doit être égal à '/C FichierBatch.bat
ParamètresDuBatch'. Cette méthode permet d'exécuter un batch
sans erreurs, de Windows 95 à Windows XP.
Exécution du batch "C:\bin\batch.bat", ayant les paramètres "-

param1 -param2 : "
ShellExecute(
Application.Handle,
'open,'
PChar(GetEnvironmentVariable('ComSpec,))'
/'C batch.bat -param1 -param2,'
'c:\bin,'
SW_SHOW;)
Exécution d'un batch "c:\bin\batch.bat" comme s'il était exécuté

depuis le répertoire "c:\travail", avec les paramètres "-param1 "
:
ShellExecute(
Application.Handle,
'open,'
PChar(GetEnvironmentVariable('ComSpec,))'
/'C c:\bin\batch.bat -param1,'
'c:\travail,'
SW_SHOW;)
Récupération et conversion des informations d'un raccourci

Windows:
-Clic droit sur le raccourci, puis "Propriétés."
-Pour la commande ShellExecute, les paramètres seront :
hwnd : Application.Handle
Operation : 'open'
FileName : Le contenu de la ligne "Cible."
Parameters : S'il y a des paramètres après l'exécutable dans
"Cible", mettez-les ici et pas dans FileName.
Directory : Le contenu de la ligne "Démarrer dans."
ShowCmd : Suivant la liste "Exécuter: "
Fenêtre normale : mettre SW_SHOW .

Réduite : mettre SW_SHOWMINIMIZED .
Agrandie : mettre SW_SHOWMAXIMIZED .
Exemple de raccourci:
Cible = "C:\Program Files\Microsoft IntelliPoint\dplaunch.exe"
Mouse CPL
Démarrer dans = "C:\Program Files\Microsoft IntelliPoint"\
Exécuter : Fenêtre normale
L'appel sera :
ShellExecute(
Application.Handle,
'open,'
'C:\Program Files\Microsoft IntelliPoint\dplaunch.exe','Mouse
CPL,'
'C:\Program Files\Microsoft IntelliPoint,'\SW_SHOW );
Exécuter un programme console en utilisant les redirections .
ShellExecute(0,nil, PChar(GetEnvironmentVariable('ComSpec')),
PChar('/C Net View > Resultat.txt'), nil, 0) ;
Le résultat de la fonction ShellExecute est un entier. S'il est
inférieur ou égal à 32, l'exécution a échoué. S'il est
strictement supérieur à 32, le processus a été lancé
correctement. Pour surveiller la fin du processus engendré, il
est conseillé d'utiliser CreateProcess au lieu de ShellExecute.
Les codes d'erreur de ShellExecute sont symboliques. Ils
correspondent à ceci sur une cible Win32 :
: 0Erreur critique (mauvais paramètres en général, les vérifier

tous). Si les paramètres sont corrects, un crash système est
imminent .
ERROR_BAD_FORMAT : Le fichier n'est pas un exécutable (vérifier
FileName .)
SE_ERR_ACCESSDENIED : Accès au fichier refusé (vérifier les
droits de l'utilisateur .)
SE_ERR_ASSOCINCOMPLETE : Le type de document n'est pas
correctement géré (vérifier Filename ou réinstaller
l'application gérant le document .)
SE_ERR_DDEBUSY : Serveur DDE occupé. Réessayer plus tard .
SE_ERR_DDEFAIL : La transaction DDE a échoué. Demander s'il faut
refaire un essai ou pas .
SE_ERR_DDETIMEOUT : La transaction DDE a été trop longue.
Demander s'il faut refaire un essai ou pas .
SE_ERR_DLLNOTFOUND : Une DLL requise n'a pas été trouvée
(vérifier FileName et Directory .)
SE_ERR_FNF : Le fichier n'a pas été trouvé (vérifier FileName et
Directory .)
SE_ERR_NOASSOC : L'extension du fichier n'est pas gérée (il
manque une application à l'utilisateur, lui demander de
l'installer .)
SE_ERR_OOM : Plus assez de mémoire pour effectuer l'opération
(demander à l'utilisateur de fermer des applications, ou libérer
de la mémoire .)
SE_ERR_PNF : Chemin non-trouvé (vérifier Directory, parfois
aussi FileName .)
SE_ERR_SHARE : Une erreur de partage s'est produite (le fichier
est utilisé par quelqu'un d'autre, ou par un autre programme, en
mode exclusif .)
On peut tester directement le code d'erreur :

Var
Code : Cardinal;
Begin
//On appelle ShellExecute "normalement."
Code := ShellExecute; ).....(
//Ensuite, on vérifie si l'exécution a été correcte:

//Deux méthodes possibles : avec ou sans exceptions.
If (Code<=32) Then
//Affichage du message d'erreur "propre", sans exceptions.
//Le résultat de SysErrorMessage est une chaîne normale, dans
la langue de l'OS.
ShowMessage(SysErrorMessage(Code;))
If (Code<=32) Then
//Affichage du message d'erreur "hard", AVEC levée d'exception.
//Remplacer par RaiseLastWin32Error sur les anciennes versions
de Delphi.
RaiseLastOSError;
End;
Remarque : la fonction WinExec ne doit plus être utilisée, elle

n'est présente que pour des soucis de compatibilité .
Comment formater l'affichage d'un réel ?
Pour transformer un réel en chaîne sans formatage particulier il

faut utiliser la fonction FloatToStr(Value:Extended):String;
Mais dans la plupart des cas, il est utile de formater le nombre

de décimales. Pour ce faire il y a différentes fonctions dans
Delphi : FloatToStrF(), FormatFloat() ou Format.)(
Par exemple pour afficher une valeur avec deux chiffres après la
virgule :
Var f:Real;
begin
f:=12345.6789;
ShowMessage(FloatToStrf(f,ffFixed,8,2));
ShowMessage(FormatFloat('0.00',f));
ShowMessage(Format('%8.2f',[f]));
end;
Voir l'aide en ligne pour l'utilisation de ces fonctions.
Comment transformer un réel en entier ?
Pour convertir un réel en entier il faut utiliser les fonctions

suivantes:
Fonction Trunc(X:Extended):Integer;
Trunc ajuste à l'entier le plus petit. Exemples:
Trunc(1.2) donne 1
Trunc(1.9) donne 1
Trunc(-1.4) donne -1
Fonction Round(X:Extended):Integer;
Round arrondi à l'entier le plus proche, dans le cas ou la
valeur est juste entre deux entiers, c'est l'entier pair qui est
choisi. Exemples:
Round(1.2) donne 1
Round(1.9) donne 2
Round(1.5) donne 2
Round(2.5) donne 2
Round(2.500001) donne 3
Round(-1.4) donne -1
Round(-1.5) donne -2
function Ceil(X:Extended):Integer; ( unité Maths)

Ceil arrondi à l'entier supérieur
Ceil(1.2) donne 2
Ceil(1.9) donne 2
Ceil(-1.5) donne -1
function Floor(X:Extended):Integer; ( unité Math )

Floor arrondi à l'entier inférieur
Floor(1.2) donne 1
Floor(1.9) donne 1
Floor(-1.5) donne -2
Comment changer le caractère décimal par défaut ?
En fonction des ordinateurs et de la configuration des options

régionales, le caractère décimal par défaut n'est pas toujours
le même. Si votre application est sensible à ce caractère, il
est conseillé de le fixer à l'initialisation de l'application.
Par exemple dans la section Initialization de la fiche
principale:
...
Initialization
DecimalSeparator;'.'=:
end.
Ainsi le caractère sera toujours le même. Il faut aussi penser à

gérer la saisie de ce caractère dans les TEdit devant contenir
des nombres réels:
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char;)

begin
If (Key=',') Or (Key='.') Then
Key:=DecimalSeparator ;
end;
Comment arrondir un réel ?
Pour arrondir un réel, utiliser la fonction SimpleRoundTo de

l'unité Math.
Exemple:
showMessage(floatToStr(SimpleRoundTo(1.235,-2))) ;
// Affiche 1.24
Si cette fonction n'est pas disponible dans votre version de
Delphi, vous pouvez utiliser la fonction suivante :
uses
Math ;
function Arrondir(nombre : extended ; nbDecim : integer) :

extended;
var
p10 : extended ;
begin
2 { étant le cas le plus fréquent, on le traite directement}
if (nbDecim = 2) then
result := round(nombre * 100) / 100
else
begin
p10 := Power(10,nbDecim) ;
result := round(nombre * p10) / p10 ;
end ;
end ;
Exemples:
memo1.Lines.Add(floatToStr(arrondir(12,2))) ;
memo1.Lines.Add(floatToStr(arrondir(13.59,1))) ;
on obtient:
22 /2,,1/0,2 /0,200 /2 /2,1 / 2,10/ 2,10, / 2,10,1
Comment élever un réel X à la puissance Y ?
Cette fonctionnalité est proposée par la fonction Power,

déclarée dans l'unité Math.
Syntaxe Delphi:
function Power(const Base, Exponent: Extended): Extended;
Description
Power élève Base à n'importe quelle puissance. Pour les
exposants fractionnels ou supérieurs à MaxInt, le paramètre Base
doit être supérieur à 0.
Ainsi, pour récupérer 2.5^6, effectuez :

uses Math;
...
Value := Power(2.5, 6) ;
Astuce : pour calculer la racine cubique d'un réel, utilisez :

uses Math;
...
Value := Power(Value, 1/3) ;
Comment comparer deux réels ?
Lorsque l'on compare 2 nombres à virgule flottante avec

l'opérateur =, on a parfois des surprises : 2 nombres à priori
égaux ne le sont pas. Ceci est dû à la représentation en virgule
flottante qui est une approximation du nombre et non une
représentation exacte (voir ci-dessous pour des explications
plus poussées). Par exemple :
var
a : double;
begin
a := 11 + 1.11;
if (a = 12.11) then
showMessage('égal’);
else
showMessage('pas égal') // <-- affiche ce message
end;
Heureusement, à partir de Delphi 6, Borland nous fournit 3

fonctions dans l'unité Math qui sont :
//Indique si deux valeurs en virgule flottante sont
(approximativement) égales.
function SameValue(const A, B: Single; Epsilon: Single = 0):
Boolean; overload;
Les 2 fonctions suivantes utilisent SameValue :

//Indique si une variable ou une expression en virgule
flottante est évaluée à zéro ou à une valeur très proche de
zéro.
function IsZero(const A: Single; Epsilon: Single = 0): Boolean;
overload;
//Renvoie la relation existant entre deux valeurs numériques.

function CompareValue(const A, B: Single; Epsilon: Single = 0):
TValueRelationship; overload;
Ces trois fonctions sont définies pour des Single, Double et

Extended. CompareValue est également définie pour Integer et
Int64. Le code ci-dessus qui ne fonctionnait pas devient alors :
uses Math;
var
a : double;
begin
a := 11 + 1.11;
if sameValue(a,12.11) then
showMessage('égal') // <-- affiche ce message
else
showMessage('pas égal’) ;
end;
L'aide de Delphi nous apprend qu'Epsilon est la quantité

maximale dont A et B peuvent s'éloigner tout en étant
considérées comme égales. Par défaut cette valeur est 0 mais en
regardant le code, on constate que si espilon est à 0 (ce qui
n'aurait pas de sens), cette valeur est corrigée.
Si vous avez une version antérieure à Delphi 6
Il faut écrire une fonction qui se charge du travail. La valeur

de Epsilon dépend de la précision des types réels comparés:
function EgaliteReels(n1,n2 : extended) : boolean;
begin
result := Abs(n1 - n2) < Min(abs(n1),abs(n2)) * 1E-16;
end;
function EgaliteReels(n1,n2 : double) : boolean;

begin
end;
function EgaliteReels(n1,n2 : single) : boolean;

begin
end;
Quelques précisions sur le calcul flottant
Pour aborder le calcul flottant je vous invite à vous reporter à

ce document. Il aborde les notions de nombre flottant (mantisse,
précision), de représentation normalisée, des notions d'arrondi.
Et surtout il nous renvoit vers la Norme IEEE 754 que vous
pouvez également consulter à cet endroit.
Les arrondis corrects de la norme IEEE 754, font qu'il est

pratiquement impossible de comparer deux extended par le simple
test suivant:
x,y: extended;
if x = y then //pas bien
Pour résoudre ce problème de façon simple plusieurs méthodes

sont à notre disposition.
-La première consiste à calculer la différence entre nos deux
extended x et y puis de vérifier que cette différence est
inférieure à epsilon (1 > epsilon > 0) que nous aurons fixé .
Cela donne:
|x - y | < epsilon
Rappelons que x et y sont des flottants normalisés, on peut
alors écrire
x = m1 10exp(a) et y = m2 10exp(b)
donc,
|m1 10exp(a) - m2 10exp(b)| < epsilon
Puisque x et y sont des nombres très proche dans le meilleur des
cas nous aurons a = b, donc
(|m1-m2) 10exp(a)| < epsilon
-La seconde méthode pour comparer les nombres x et y peut

partir de la constatation que si x et y sont très proches alors
le quotient de ces deux nombres est proche de 1. On peut alors
écrire:
-2epsilon < |x/y| < 1 + epsilon
-epsilon < |x/y| - 1 < epsilon
soit encore
|-2|x/y|| < epsilon (en ayant multiplié chacun des membres par -
1)
En remplaçant x et y par leur représentation flottante
normalisée, nous obtenons
(|-2|m1 10exp(a))/(m2 10exp(b))|| < epsilon
Comme plus haut, a = b dans le meilleur des cas, donc
|-2|m1/m2|| < epsilon
Ce qui est plus simple que dans la première méthode. En effet

ici le calcul ne prendra en compte que les mantisses des
flottants.
Comment afficher des documents au format Adobe Acrobat (PDF)

dans une application Delphi ?
Adobe propose un outil gratuit de visualisation appelé Acrobat

Reader. L'installation de cet outil intègre un contrôle ActiveX
qui peut être utilisé pour afficher des documents PDF dans
n'importe quelle application développée avec un langage
supportant les objets COM. Il est donc très facile d'utiliser ce
contrôle ActiveX dans une application Delphi.
Il vous faut commencer par installer Acrobat Reader sur votre

ordinateur de développement. Notez que cette installation sera
également nécessaire sur les ordinateurs devant exécuter votre
programme. Vous pouvez trouver le programme d'installation ici :
http://www.adobe.fr/products/acrobat/readstep2.html
Une fois l'installation terminée, vous devez importer le

contrôle ActiveX dans Delphi. Celui-ci s'appelle "Acrobat
Control for ActiveX".
Si vous avez suivi la procédure sans modifier le nom de la

palette utilisée, vous devriez trouver un nouveau composant dans
la palette ActiveX. Ce nouveau composant intitulé TPdf peut être
posé sur une fenêtre Delphi comme n'importe quel autre
composant.
Vous pouvez à présent l'utiliser dans votre application en

utilisant sa méthode LoadFile :
Pdf1.LoadFile('fichier.pdf’) ;
Pour plus d'information sur les méthodes proposées par ce
composant, vous pouvez étudier l'unité Delphi contenant la
définition de ses interfaces (par défaut PdfLib_TLB.pas située
dans le dossier Imports de Delphi) ou télécharger les documents
fournis par Adobe à l'adresse suivante :
http://partners.adobe.com/asn/tech/pdf/acrobatsdks.jsp
Attention, le téléchargement de certains documents nécessite de
s'être enregistré sur le site mais cet enregistrement est
gratuit et sans restriction particulière.
Comment effacer le contenu d'un TImage ?
Pour effacer l'image affichée dans un TImage, il suffit

d'assigner nil a sa propriete Picture :
Image1.Picture := nil;
Comment cacher la barre de menu ?
Pour cacher la barre de menu d'une fiche, il suffit de mettre sa

propriété Menu à nil :
Self.Menu := nil ;
Pour la réactiver, on remet juste le nom du Menu

Self.Menu := MainMenu ;
Comment bloquer la saisie dans un Memo en Majuscule ?
Pour restreindre la saisie de l'utilisateur à des majuscules

dans un TMemo, on peut utiliser le code suivant dans l'évènement
OnKeyPress :
Key := UpCase(Key) ;
Cependant, cette méthode ne gère pas les caractères accentués!
Pour gérer correctement les caractères accentués, on peut

utiliser le code suivant, en exploitant le gestionnaire de
l'évènement OnCreate de la fiche :
TEdit(Memo1).CharCase := ecUpperCase;
Plus générallement, le code suivant fonctionne pour tous les
descendants de TCustomEditControl :
SetWindowLong(Memo1.Handle,GWL_STYLE,GetWindowLong(Memo1.Handle,
GWL_STYLE)Or ES_UPPERCASE);
Comment encoder/décoder une date ou un temps ?
Pour affecter une date à une variable de type TDate ou

TDateTime, il suffit d'utiliser la fonction EncodeDate(Year,
Month, Day: Word):TDateTime.
Pour récupérer les éléments d'une variable TDate, on utilise la
procédure DecodeDate(Date:TDateTime; var Year, Month, Day:
Word).
var
MaDate: TDate;
Jour, Mois, Annes: Word;
begin
//Jour, Mois et Annee doit être une date valide
//Pour encoder:
MaDate := EncodeDate(Annee,Mois,Jour);
//Pour décoder
DecodeDate(MaDate, Annee, Mois, Jour);
end;
Pour affecter un temps à une variable de type TTime ou

TDateTime, il suffit d'utiliser la fonction EncodeTime. Pour
récupérer les éléments d'une variable TTime, on utilise la
fonction DecodeTime .
var
MonHeure : TTime;
Heure, Minute, Seconde, milliSec : Word;
begin
//Heure, Minute, Seconde et milliSec doivent être un temps
valide
//Pour encoder
MonHeure := EncodeTime(Heure, Minute, Seconde, milliSec);
ShowMessage(TimeToStr(MonHeure));
//Pour décoder
DecodeTime(MonHeure,Heure, Minute, Seconde, milliSec);
end;
Comment formater une date ?
Pour formater un type TDateTime en chaîne de caractères il faut

utiliser la fonction FormatDateTime .
var
DateChaine: string;
begin
DateChaine := FormatDateTime('"Nous sommes le" dd/mm/yyyy", il
est "hh:ss', Now) ;
end;
Les spécificateurs de format sont détaillés dans l'aide de

delphi de cette fonction. Les plus utilisés sont les suivants :
yyyy : année sur quatre chiffres : 2005
yy : année sur deux chiffres : 05
mmmm : mois en clair : Janvier
mmm : mois en abrégé : Jan
mm : mois sur deux chiffres : 01
m : mois sur un ou deux chiffres : 1
dddd : jour en clair : Dimanche
ddd : jour en abrégé : Dim
dd : jour sur deux chiffres : 09
d : jour sur un ou deux chiffres : 9
hh : heure sur deux chiffres : 01
h : heure sur un ou deux chiffres : 1
nn : minute sur deux chiffres : 01
n : minute sur un ou deux chiffres : 1
ss : seconde sur deux chiffres : 01
s : seconde sur un ou deux chiffres : 1
z : millisecondes sans les préfixer d'un zéro (0 à 999)
zzz : millisecondes en les préfixant d'un zéro (000 à 999).
Comment calculer le nombre de jours entre deux dates ?
Pour calculer la différence entre deux dates, on peut utiliser

plusieurs méthodes :
En passant directement par les dates
var
Date1, Date2 : TDateTime;
Diff : Extended;
Jour1, Mois1, Annee1 : Word;
begin
Date1 := EncodeDate(Annee1, Mois1, Jour1);
Diff := Date2 - Date1;
end;
En passant directement par une fonction

var
Diff : Extended;
begin
Diff := DaysBetween(Date2, Date1);
end;
En passant par les jours Juliens

var
Diff : Extended;
begin
Diff := DateTimeToJulianDate(Date2)-
DateTimeToJulianDate(Date1);
end;
La variable Diff représente la différence entre les deux dates,

mais dans le cas où le nombre de jours dans un intervalle il y a
lieu d'ajouter 1 au résultat (problème de bornes).
Comment additionner ou soustraire des jours à une date ?
Pour ajouter ou soustraire un nombre de jours à une date, on

peut utiliser plusieurs méthodes :
En utilisant directement la date
var
Date1 : TdateTime;
NbJour : Integer;
begin
Date1 := EncodeDate(2002, 11, 1);
Date1 := Date1 + NbJour;
{ou bien Date1 := Date1 - NbJour;}
end;
La variable NbJour peut être positive ou négative.
En utilisant des fonctions
uses
DateUtils;
var
Date1 : TdateTime;
NbJour : Integer;
begin
Date1 := EncodeDate(2002, 11, 1);
Date1 := IncDay(Date1, NbJour);
La variable NbJour peut être positive ou négative. On peut
également utiliser les fonctions IncMonth(), IncYear() et
IncWeek().
Date1 := IncMonth(Date1, NbMois);
Date1 := IncYear(Date1, NbAnnee);
Date1 := IncWeek(Date1, NbSemaine);
NbMois, NbAnnee et NbSemaine peuvent être positifs ou négatifs.
En utilisant le jour Julien
uses
DateUtils;
var
Date1 : TdateTime;
Annee, Mois, Jour, Heure, Minute, Seconde, milliSec :
Word;
NbJour : Integer;
JourJul : Double;
begin
Date1 := EncodeDateTime(Annee, Mois, Jour, Heure,
Minute, Seconde, milliSec);
JourJul := DateTimeToJulianDate(Date1) + NbJour;
Date1 := JulianDateToDateTime(Date1);
end;
NbJour peut être un entier ou un réel positif ou négatif. La
variable JourJul intègre l'heure et est entière pour midi.
Comment modifier la largeur de la liste déroulante d’un

comboBox ?
Le message CB_ SETDROPPEDWIDTH permet de définir la largeur
maximum en pixels d’une liste déroulante d’un comboBox.
CB_SETDROPPEDWIDTH
wParam = (WPARAM) wWidth, // width of list box, in pixels
lParam = 0, // not used, must be zero
Pour définir la largeur de cette liste déroulante au moment où

votre combobox prend le focus il suffit par exemple de coder
l’événement OnEnter d’une des deux façons suivantes. Ces deux
méthodes sont équivalentes.
procedure TForm1.ComboBox1Enter(Sender: TObject);
begin
//La largeur liste déroulante sera de 300 pixels
ComboBox1.Perform(CB_SETDROPPEDWIDTH, 300, 0);
end ;
ou
procedure TForm1.ComboBox1Enter(Sender: TObject);
begin
//La largeur liste déroulante sera de 300 pixels
SendMessage(ComboBox1.handle, CB_SETDROPPEDWIDTH, 300,
0);
end ;
Remarques:
1. Cela fonctionne également avec un TDBComboBox ou un
TDBLookupComboBox.
2. Vous pouvez retouver dans la MSDN Library, la section
traitant des Combo boxes avec notamment la liste de tous les
messages et de toutes les notifications.
----------------------------------------------------------------
procedure TForm1.Edit1Change(Sender: TObject);

begin
if Trim(Edit1.Text)='' then table1.Filtered:=False else
begin
Table1.Filter:=('NOM='+QuotedStr(edit1.Text+'*'));
table1.Filtered:=true;
end;
end;
----------------------------------------------------------------
Cet exemple affiche un message sur la barre d'état d'une fiche
qui indique la valeur du compteur des enregistrements d'une
table après qu'un enregistrement ait été supprimé.
procedure TForm1.Table1AfterDelete(DataSet: TDataSet);

begin
StatusBar1.SimpleText := Format('La table contient maintenant
%d enregistrements', [DataSet.RecordCount]);
end;
----------------------------------------------------------------
Cet exemple met à jour la barre d'état d'une fiche avec un

message lorsqu'un événement AfterEdit survient.
procedure TForm1.Table1AfterEdit(DataSet: TDataSet);

begin
StatusBar1.SimpleText := 'Modification de l''enregistrement'
+ IntToStr(DataSet.RecNo);
end;
----------------------------------------------------------------
Procedure TFARTICLE.Table1AfterScroll(DataSet: TDataSet);

begin
StatusBar1.SimpleText := 'Enregistrement: ' +
IntToStr(Table1.RecNo) + ' de ' + IntToStr(Table1.RecordCount);
end;
End.
Pour déplacer la forme & les panel (RM) :
procedure MouseDownDrag(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);
procedure TForm1.MouseDownDrag(Sender: TObject; Button:

TMouseButton;
Shift: TShiftState; X, Y: Integer);
Const SC_DragMove=$F012;
begin
ReleaseCapture;
if Sender is Tlabel then
((Sender as
Tlabel).Parent).Perform(WM_SysCommand,SC_DragMove,0)
else
begin
if Sender is TImage then
((Sender as
TImage).Parent).Perform(WM_SysCommand,SC_DragMove,0)
else
(Sender as TControl).Perform(WM_SysCommand,SC_DragMove,0);
end;
end;
Raccourci ctrl+P :

begin
if (ssCtrl in Shift)
then
begin
case char(key) of
'P', 'p': AboutBox.ShowModal;
'N','n' :close;
end;
end;
end;
----------------------------------------------------------------

Langue

Delphi Imp2

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Delphi Imp2

Transféré par

Droits d'auteur :

Formats disponibles

1- General

Affichage d'un forme de démarrage

Lancer l'application qu'une seule fois

Faire défiler le titre d'une TForm

Sélectionne tout le texte de RichEdit

Bitmap sur écran

procedure TForm1.Button1Click(Sender: TObject);

Effacer le texte sélectionné

Memo1.CutToClipboard; Copie le texte sélectionné du contrôle

procedure TStandardTab.RadioGroup1Click(Sender: TObject);

procedure TForm1.Button1Click(Sender: TObject);

Select help file:

Recherche un texte dans Richeedit

procedure TForm1.Button1Click(Sender: TObject);

procedure TForm1.FindDialog1Find(Sender: TObject);

StartPos := SelStart + SelLength

{ ToEnd indique la longueur entre StartPos et la fin du

ToEnd := Length(Text) - StartPos;

Positionner le pointeur sourie :

Appeler la procédure windows suivante :

Sortir d'une boucle avec la touche ESC

procedure TForm1.Button1Click(Sender: TObject);

Dessiner un Bitmap sur l'écran

procedure TForm1.Button1Click(Sender: TObject);

Rendre une Form transparente

Placez un bouton sur Form1 puis ajouter le code suivant:

procedure TForm1.FormCreate(Sender: TObject);

Works on Windows 98/2000

Connaitre la mémoire libre disponible

procedure TForm1.Button1Click (Sender: TObject);

Faire une capture d'écran

//Copie d'écran de la fenêtre active

procedure TForm1.Button1Click(Sender: TObject);

procedure TForm1.Button2Click(Sender: TObject);

procedure TForm1.Button1Click(Sender: TObject); //Öffnen - Open

procedure TForm1.Button2Click(Sender: TObject); //Schliessen-

Vérifier s'il y a une disquette dans le lecteur

function DiskInDrive(Drive: Char): Boolean;

Utiliser la fonction Autorun d'un CD

Créer dans le répertoire racine du cd un fichier texte

Déplacer un item d'un TListBox Items avec la souris

procedure TForm1.ListBox1MouseMove(Sender: TObject; Shift:

Changer le format de la date

//change le format de la date

//donne le nom du jour et du mois

Supprimer le beep dans un Tedit quand on appuie sur entrer

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

Parcourir d'une image :

Vérifier si un string correspond à une adresse Email valide

function IsEMail(EMail: String): Boolean;

procedure TForm1.Button1Click(Sender: TObject);

Piloter Internet Explorer par OLE

procedure OpenIE(aURL: string);

procedure TForm1.Button1Click(Sender: TObject);

Lancer une URL dans le navigateur par défaut

Lancement de la fenetre proprietes système

rajouter Shellapi dans la clause USES

Connaitre le répertoire temporaire par défaut de windows

procedure TForm1.Button1Click(Sender: TObject);

Lancement de la fenetre de config de l'heure

rajouter Shellapi dans la clause USES

Lancer l'économiseur d'écran(écran de veille) :

Appeler la procédure windows suivante :