FAQ DelphiConsultez toutes les FAQ

1
2
3
4
5
6
7
program Project1; 
{$APPTYPE CONSOLE} 
uses sysutils; 
  
begin 
  // Insérer le code utilisateur ici 
end.

1
2
3
4
5
6
7
8
9
program Project1; 
{$APPTYPE CONSOLE} 
uses sysutils; 
  
{$R *.RES}             // Ligne à ajouter  
  
begin 
  // Insérer le code utilisateur ici 
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
program Upper;  
{$APPTYPE CONSOLE}  
// Redirection de type 'PIPE', comportement similaire au programme FIND.EXE ou SORT.EXE 
// Renvoie une chaîne reçue en entrée ( input)  en majuscules sur la sortie (output)  
uses sysutils;  
  
Var Chaine: String;  
  
procedure CloseFile;  
begin  
  Close(INPUT);  
  Close(OUTPUT);  
end;  
  
Begin  
  try  
    Assign(INPUT,'');       { Entrée standard }  
    Reset(INPUT);           { Le fichier existe; reset en lecture seule}  
    Assign(OUTPUT,'');       { Sortie standard}  
    Rewrite(OUTPUT);         { Le fichier n'existe pas ; rewrite en écriture seule}  
  
    While not(Eof) Do  
    Begin  
      Readln(INPUT,Chaine);      
      Writeln(OUTPUT,UpperCase(chaine));  
    end  
  Finally  
    CloseFile;  
  end;  
end.

1
2
3
@echo off  
 rem Convertir en majuscule le contenu du fichier minuscule.txt 
 Type Minuscule.txt|Upper>Majuscule.txt

Dir> résultat.txt

Ftp<Send.txt

Echo.|Time

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
program Project1; 
  
{$APPTYPE CONSOLE} 
  
uses sysutils, Windows; 
  
var 
  Han: THandle; 
begin 
  Han := GetStdHandle(STD_OUTPUT_HANDLE); 
  if (Han <> INVALID_HANDLE_VALUE) then 
  begin 
    // Insérer le code utilisateur ici 
  end 
  else 
  begin 
    Write('Erreur lors de l''initialisation de l''application !'); 
    ReadLn; 
  end; 
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
program Project1; 
  
{$APPTYPE CONSOLE} 
  
uses 
  SysUtils, Windows; 
  
var 
  han: THandle; 
  dw: DWord; 
  buf: TInputRecord; 
begin 
  han := GetStdHandle(STD_INPUT_HANDLE); 
  Write('Continuer [O/N] ?'); 
  repeat 
    FlushConsoleInputBuffer(han); 
    dw := 0; 
    ReadConsoleInput(han, buf, 1, dw); 
  until (buf.EventType = KEY_EVENT) and (buf.Event.KeyEvent.AsciiChar in ['o','O','n','N']); 
  
  WriteLn(buf.Event.KeyEvent.AsciiChar); 
  
  case buf.Event.KeyEvent.AsciiChar of 
    'o','O': WriteLn('OUI !!'); 
    'n','N': WriteLn('NON !!'); 
  end; 
  ReadLn; 
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
program TestIO; 
{$APPTYPE CONSOLE} 
uses sysutils, Windows; 
  
var 
  ConsoleHandle : THandle; 
  
Function GetHandleType(Handle:THandle): String; 
begin 
  case GetFileType(Handle)of 
   FILE_TYPE_UNKNOWN : Result:='type inconnu ou erreur.'; 
   FILE_TYPE_DISK    : Result:='fichier disque.'; 
   FILE_TYPE_CHAR    : Result:='fichier caractère.'; 
   FILE_TYPE_PIPE    : Result:='socket, un pipe nommé, ou un pipe anonyme.'; 
   //FILE_TYPE_REMOTE inutilisé 
  end; 
end; 
  
begin 
  ConsoleHandle := GetStdHandle(STD_OUTPUT_HANDLE); 
  WriteLn('Sortie standard : '+ GetHandleType(ConsoleHandle)); 
  Readln; 
  ConsoleHandle := GetStdHandle(STD_INPUT_HANDLE); 
  WriteLn('Entrée standard : '+ GetHandleType(ConsoleHandle)); 
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Echo Off 
Set DirPrgName= 
Set PrgName=%DirPrgName%TestIO.exe 
  
 Rem Différent cas de figure 
Echo Test avec : %PrgName% 
%PrgName% 
pause&Echo. 
  
Echo Test avec : %PrgName%^>Result1.txt 
%PrgName%>Result1.txt 
Type Result1.txt 
pause&Echo. 
  
Echo Test avec : %PrgName%^|more 
%PrgName%|more 
pause&Echo. 
  
Echo Test avec : %PrgName%^|more^>Result2.txt 
%PrgName%|more>Result2.txt 
Type Result2.txt 
pause&Echo. 
  
Echo Test avec : %PrgName%^>Result1.txt 
%PrgName%<Result1.txt 
pause&Echo. 
  
Echo Test avec : %PrgName%^<Result1.txt^>Result3.txt 
%PrgName%<Result1.txt>Result3.txt 
Type Result3.txt 
pause&Echo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
program Test1Console; 
{$APPTYPE CONSOLE} 
uses sysutils, Windows; 
  
var 
  ConsoleHandle: THandle; 
  ConsoleScreenBufferInfo: _CONSOLE_SCREEN_BUFFER_INFO; 
begin 
  ConsoleHandle := GetStdHandle(STD_OUTPUT_HANDLE); 
  GetConsoleScreenBufferInfo(ConsoleHandle,ConsoleScreenBufferInfo); 
  // Afficher le texte en bleu : 
  SetConsoleTextAttribute(ConsoleHandle,FOREGROUND_BLUE); 
  WriteLn('Ce texte est Bleu !!!'); 
  
  // Afficher le texte en jaune (Avec Luminosité + Rouge + Vert = Jaune) : 
  SetConsoleTextAttribute(ConsoleHandle,FOREGROUND_GREEN  
                 or FOREGROUND_RED or FOREGROUND_INTENSITY); 
  ReadLn; 
   // Rétabli les couleurs d'origine 
  SetConsoleTextAttribute(ConsoleHandle,ConsoleScreenBufferInfo.wAttributes); 
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
program console;  
  
{$APPTYPE CONSOLE}  
uses Windows, SysUtils;  
  
function ConProc(CtrlType : DWord) : Bool; stdcall; far;  
var  
 S : String;  
begin  
  case CtrlType of  
    CTRL_C_EVENT : S := 'CTRL_C_EVENT';  
    CTRL_BREAK_EVENT : S := 'CTRL_BREAK_EVENT';  
    CTRL_CLOSE_EVENT : S := 'CTRL_CLOSE_EVENT';  
    CTRL_LOGOFF_EVENT : S := 'CTRL_LOGOFF_EVENT';  
    CTRL_SHUTDOWN_EVENT : S := 'CTRL_SHUTDOWN_EVENT';  
  else  
    S := 'UNKNOWN_EVENT';  
  end;  
  // Code de finalisation  
 MessageBox(0, PChar(S + ' détecté'), 'Win32 Console', MB_OK);  
  
 Result := True;  
end;  
  
begin  
SetConsoleCtrlHandler(@ConProc, True);  
Writeln('entrée pour terminer');  
Readln;  
 // Désactive le Handler  
 // SetConsoleCtrlHandler(@ConProc, False);  
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Var 
 NouveauTitre : String; 
 AncienTitre  : Array[0..512]of char; 
  
begin 
    // Mémorise le titre courant de la fenêtre 
  GetConsoleTitle(PChar(@AncienTitre),SizeOf(AncienTitre)); 
   // Construit un nom unique 
  NouveauTitre:=Format('%d%d', [GetTickCount,GetCurrentProcessId]); 
   // On donne un titre unique à la console 
  SetConsoleTitle(Pchar(NouveauTitre)); 
  Writeln('masque la fenêtre'); 
    // Délai pour s'assurer que le titre est bien mis à jour. Au minimum Sleep(40 ) 
  Sleep(2000); 
   // Masque la fenêtre 
   // FindWindows obtient le handle. Cet appel retourne le handle ou NIL si l'opération échoue. 
  ShowWindow( FindWindow(NIL, PChar(NouveauTitre)),SW_HIDE); 
  
  Writeln('Affiche la fenêtre'); 
  Sleep(2000); 
   // Affiche la fénêtre précédemment masquée 
  ShowWindow( FindWindow(NIL,PChar(NouveauTitre) ),SW_SHOW); 
   // Réattribue le titre originel 
  SetConsoleTitle(PChar(@AncienTitre)); 
end.

1
2
3
4
5
6
7
8
9
10
11
Function GetConsoleWindow:HWnd;Stdcall; external 'Kernel32.dll'; 
Var 
 Titre : Array[0..512]of char; 
  
begin 
    // Mémorise le titre courant de la fenêtre 
  GetConsoleTitle(PChar(@Titre),SizeOf(Titre)); 
  ... 
  ShowWindow(GetConsoleWindow, SW_HIDE); 
  ... 
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
program consolecls; 
  
{$APPTYPE CONSOLE} 
  
uses 
  SysUtils,  Windows; 
  
procedure cls(hConsole : THandle); 
const 
   coordScreen: TCoord=(X:0;Y:0);   // Position d'origine du curseur 
  
var cCharsWritten: DWord; 
    csbi: TConsoleScreenBufferInfo; 
    dwConSize : DWord; 
  
begin 
   // Obtient le nombre de caractères contenu dans le buffer courant 
   if not GetConsoleScreenBufferInfo(hConsole, csbi ) 
    then exit; 
   dwConSize:=csbi.dwSize.X * csbi.dwSize.Y; 
  
   // remplit la totalité de l'écran avec des espaces. 
   if not FillConsoleOutputCharacter( hConsole,#32,dwConSize, coordScreen, cCharsWritten ) 
    then exit; 
  
   // Obtient l'attribut courant du texte. 
   if not GetConsoleScreenBufferInfo( hConsole, csbi ) 
    then Exit; 
  
   // Affecte les attributs du buffer en conséquence. 
   if not FillConsoleOutputAttribute( hConsole, csbi.wAttributes,dwConSize, coordScreen, cCharsWritten ) 
     then exit; 
  
   // Place le curseur aux coordonnées d'origine. 
   SetConsoleCursorPosition( hConsole, coordScreen ); 
end; 
  
var 
  HandleConsole : THandle; 
begin 
  HandleConsole := GetStdHandle(STD_OUTPUT_HANDLE); 
  if (HandleConsole <> INVALID_HANDLE_VALUE) 
   then Cls(HandleConsole) 
   else  Write('Erreur lors de l''initialisation de l''application !');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
program Fullscreen; 
//Bascule un programme console en mode plein écran. 
{$APPTYPE CONSOLE} 
  
uses 
  SysUtils, 
  Windows; 
  
const 
 CONSOLE_FULLSCREEN_MODE = 1; // Mode plein écran 
 CONSOLE_WINDOWED_MODE   = 2; // Mode console ('fenêtré'). 
  
 Function SetConsoleDisplayMode(ConsoleOutput : THandle; 
          Flags : DWORD; 
 		  NewScreenBufferDimensions : PCoord):BOOL; stdcall; external 'kernel32.dll'; 
  
  
Function SetConsoleScreen(Mode:Byte):Boolean; 
var 
  ConsoleHandle: THandle; 
begin 
  Result:=False; 
  ConsoleHandle :=GetStdHandle(STD_OUTPUT_HANDLE); 
  if ConsoleHandle <> INVALID_HANDLE_VALUE 
   then Result:=SetConsoleDisplayMode(ConsoleHandle,Mode,Nil)=False 
end; 
  
Function SetFullScreen:Boolean; 
begin 
 Result:=SetConsoleScreen(CONSOLE_FULLSCREEN_MODE); 
end; 
  
begin 
 Writeln('Mode fenetre '); 
 Readln; 
 if SetFullScreen 
  then Writeln('Mode plein ecran'); 
 Readln; 
end.

MAINICON ICON "[FichierIcone].ico"

[RépertoireDelphi]\bin\brcc32.exe [MonFichierRessource].rc

{$R *.res}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function GetConsoleHwnd : HWND; 
var 
  NewWindowTitle : string; 
  OldWindowTitle : string; 
begin 
  SetLength(NewWindowTitle, 1024); 
  
  // Récupère le titre courant. 
  GetConsoleTitle(PChar(OldWindowTitle), 1024); 
  
  NewWindowTitle := Format('%d/%d', [GetTickCount, GetCurrentProcessId]); 
  
  // Change le titre. 
  SetConsoleTitle(PChar(NewWindowTitle)); 
  
  // Attend pour que le titre de la fenêtre soit changé. 
  Sleep(40); 
  
  // Cherche le nouveau titre. 
  Result := FindWindow(nil, PChar(NewWindowTitle)); 
  
  // Restaure le titre original. 
  SetConsoleTitle(PChar(OldWindowTitle)); 
end;