| | auteur : Geronimo |
Pour cela, utilisez la fonction system, déclarée dans stdlib.h, qui prend pour argument la commande à exécuter :
#include <stdlib.h>
system("dir *.*");
|
|
| | auteur : Geronimo |
Pour récupérer le résultat de l'exécution d'une commande, il suffit d'utiliser la fonction system, définie dans stdlib.h, pour lancer une commande, et de spécifier une redirection de sortie (celles-ci fonctionnent aussi bien sous DOS/Windows que sous Linux) :
#include <stdlib.h>
system("dir *.* > results.txt");
system("ls -l > results");
|
Le résultat de la commande se situe maintenant dans le fichier results.txt ou results.
|
| | auteur : Geronimo | Utilisez la fonction ShellExecute.
Pour lancer Notepad, par exemple :
ShellExecute(NULL,
"open",
"notepad.exe",
"",
"",
SW_SHOWDEFAULT
);
|
Attention, les chaînes passées en arguments de cette fonction sont des chaînes C standard. Pour passer des AnsiString en arguments, utilisez la méthode c_str() :
if (OpenDialog1->Execute())
{
ShellExecute(NULL,
"open",
"notepad.exe",
OpenDialog1->FileName.c_str(),
ExtractFilePath(OpenDialog1->FileName).c_str(),
SW_SHOW
);
}
|
|
| | auteur : Geronimo |
Cela peut être effectué grâce aux fonctions ParamCount() et ParamStr(), la seconde prenant en argument le numéro de l'argument.
Dans l'exemple suivant, nous chargeons dans un TMemo le fichier placé en argument de la ligne de commande. Placez le code suivant dans le constructeur de votre fiche :
if ( ParamCount() > 0 )
Memo1->Lines->LoadFromFile(ParamStr(1));
|
|
| | auteur : Geronimo |
Il est souvent utile d'avertir l'utilisateur par un message rapide, pour lui faire part d'une information ou pour lui signaler une erreur. Il existe différentes méthodes. Les plus simples et les plus utiles sont ShowMessage et MessageDlg.
ShowMessage permet d'afficher un message tout simple dans une fenêtre. Elle prend pour argument une AnsiString qui est le contenu du message.
ShowMessage("Tâche effectuée");
|
L'autre méthode, plus perfectionnée, est MessageDlg. Cette fonction permet de personnaliser un peu la boîte de dialogue :
MessageDlg("La tâche a été effectuée correctement", mtInformation, TMsgDlgButtons() << mbOK, 0);
|
Cette fonction permet d'afficher un message (AnsiString passée en premier argument). Le second argument indique le type de boîte de dialogue. mtInformation affiche une icône "information" dans la boîte de dialogue. Enfin, l'avant-dernier argument permet de choisir quels boutons seront disponibles dans la boîte de dialogue. Le dernier argument permet de lier la boîte de dialogue à une rubrique d'aide. Un des grands avantages de cette fonction est qu'elle permet de savoir quel bouton a été enfoncé s'il y en avait plusieurs :
if (MessageDlg("Le document n'a pas été sauvegardé, voulez-vous le sauvegarder avant de quitter ?",
mtConfirmation, TMsgDlgButtons() << mbYes << mbNo, 0) == mrYes)
Sauver();
|
Dans ce code, la méthode Sauver est appellée si le bouton Oui est cliqué. Pour plus de détails sur le fonctionnement de MessageDlg, consultez l'aide de C++Builder.
|
| | auteur : Geronimo | Lors d'un traitement long, l'application ne traite plus les messages Windows de la queue de messages.
Le résultat est en général une aplication qui ne répond plus aux évenements utilisateurs, ou qui ne se redessine plus.
Dans ce cas, il faut faire un appel à la méthode ProcessMessages de la classe Application dans la boucle. L'exemple présenté ci-dessous déclenche une tâche ininterrompue lors du clic sur un bouton. Nous dessinons un quadrillage par rebonds successifs du pinceau sur les bords de la fenêtre. Déclarons tout d'abord une variable Stop en global :
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
bool Stop;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
|
Maintenant, nous allons écrire le gestionnaire d'évènements OnClick du bouton de dessin.
void __fastcall TForm1::Button1Click(TObject *Sender)
{
static int x_inc = 1;
static int y_inc = 1;
static int X = 10;
static int Y = 10;
Stop = false;
while(!Stop)
{
Canvas->MoveTo(X, Y);
X += x_inc;
Y += y_inc;
Canvas->Pen->Color = RGB(rand()%255, rand()%255, rand()%255);
Canvas->LineTo(X, Y);
if (X > ClientWidth || X < 0) x_inc = -x_inc;
if (Y > ClientHeight || Y < 0) y_inc = -y_inc;
Application->ProcessMessages();
}
}
|
Maintenant, il nous faut pouvoir arrêter cette boucle dessin. Pour cela, nous avons vu qu'il suffit de placer la variable Stop à true. Placez un autre bouton sur la fiche. Dans son gestionnaire d'évènements OnClick, placez le code suivant :
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Stop = true;
}
|
Si un clic sur le bouton a lieu, il sera traité par l'appel à Application->ProcessMessages(). Enfin, il faut pouvoir quitter le programme. Pour cela, utilisez l'évènement OnCloseQuery de la fiche et placez-y également le code Stop = true.
|
| | auteur : Geronimo |
Utilisez la fonction Sleep en lui passant en argument le nombre de millisecondes.
Notez qu'en raison du fonctionnement interne de Windows, Sleep ne garantit qu'un minimum d'attente. En effet, Windows n'est pas un système temps-réel.
|
Consultez les autres F.A.Q.
 
|
|
