Pour changer l'icône de votre programme, utilisez Projet/Options... . Allez dans l'onglet Application et en cliquant sur le bouton Charger icône... , vous pourrez charger une nouvelle icône qui doit être au format.ico. Si vous souhaitez dessiner une nouvelle icône, utilisez l' éditeur d'images disponible dans le menu Outils de l'IDE.

Une splash screen est un écran qui est affiché pendant le chargement d'un logiciel (l'image que vous voyez quand vous démarrez C++Builder).
Pour en afficher pendant le démarrage de votre programme, créez une nouvelle fiche ( Fichier/Nouvelle fiche ), positionnez sa propriété BorderStyle à bsNone et FormStyle à fsStayOnTop . Nommez votre fiche Splash_dlg . Utilisez les options ( Projet/Options ) pour ne pas créer la fiche automatiquement au démarrage. Ensuite, affiche la fonction WinMain de votre projet ( Fichier/Voir le source ), avant les instructions Application->CreateForm(/*...*/) , placez le code suivant :

Splash_dlg=new TSplash_dlg(NULL); // Crée la fiche dynamiquement
Splash_dlg->Show(); // Affiche la fiche

Après les instructions Application->CreateForm(/*...*/) , placez le code suivant :

delete Splash_dlg; // Supprime la fiche et libère la mémoire utilisée

Ainsi, la fiche splash screen sera affichée pendant la création des autres fiches.

Les assistants sont des boites de dialogues qui vous guident à travers les étapes d'une opération (cf. programmes d'installation). Peut-être souhaitez-vous en placer un dans votre application. Pour cela, placez sur votre fiche les composants suivants : un composant Notebook qui est disponible dans l'onglet Win 3.1 de la palette de composants, et quatre boutons Button1, Button2, Button3 et Button4 que vous intitulerez respectivement Annuler, << Précédent, Suivant >> et Fin. Dans le composant Notebook, vous pouvez créer plusieurs pages dans la propriété page. En mode conception, avec un clic droit sur le composant Notebook, vous pouvez passer à la page suivante et à la page précédente. Utilisez ces commandes pour créer les différentes étapes de votre assistant, en prenant bien soin de placer la première sur la page d'index 0 (vous pouvez vérifier l'index de la page courante dans l'inspecteur d'objets à l'aide de la propriété PageIndex). Une fois cela fait, positionnez la propriété de Button4 (le bouton Fin) à false. En effet, il faut que le bouton de fin soit uniquement disponible lors de la dernière étape. Positionnez également celle de Button1 (<< Précédent) à false car il ne faut pas pouvoir appuyer sur Précédent lorsque nous sommes dans la première page de notre assistant. Nous pourrions également faire cette initialisation dans le constructeur de la fiche :

__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
    Button2->Enabled = false;
    Button4->Enabled = false;
    Notebook1->PageIndex = 0;
}

Ainsi, nous sommes sûrs que quand la fiche est créée, les boutons Précédent et Fin sont désactivée et que l'étape de l'assistant et la première (Notebook1->PageIndex = 0). Maintenant, nous allons écrire les gestionnaires d'événement des boutons. Double-cliquez sur Button1 (le bouton Annuler). Avec ce bouton, nous quittons tout simplement la fiche donc positionnez sa propriété ModalResult à mrCancel. Pour le bouton Fin, positionnez la propriété ModalResult à mrOk. Lorsque la valeur ModalResult est attribuée, la fiche se ferme et la méthode ShowModal de la fiche retourne la valeur ModalResult correspondant au bouton appuyé, ce qui nous permettra de savoir si l'utilisateur a annulé ou bien a appuyé sur le bouton Fin. Cela fait, nous allons créer le gestionnaire d'événement du bouton Button2 (Précédent). Dans ce gestionnaire d'événement, nous décrémentons la propriété PageIndex de Notebook1 afin d'obtenir la page précédente :

void __fastcall TForm1::Button2Click(TObject *Sender)
{
    if (Notebook1->PageIndex > 0)
    {
    	Notebook1->PageIndex --;
    	Button4->Enabled = false;
    	Button3->Enabled = true;
    }

    if (Notebook1->PageIndex == 0)
        Button2->Enabled = false;
}

Comme vous le constatez, nous ne décrémentons PageIndex que si cette propriété est supérieure strictement à 0, sinon, nous aurions une erreur. Remarquez que le cas ne devrait pas se présenter car le bouton sera désactivé à chaque fois que la propriété PageIndex sera nulle. C'est ce que nous faisons dans la deuxième partie de ce code. Lors d'un clic sur ce bouton, nous activons aussi le boutons Suivant et désactivons le bouton Fin. Ensuite, nous devons incrémenter la valeur de PageIndex si l'utilisateur clique sur le bouton Suivant, ce qui est fait dans l'événement OnClick de Button3 :

void __fastcall TForm1::Button3Click(TObject *Sender)
{
    if (Notebook1->PageIndex < Notebook1->Pages->Count - 1)
    {
    	Notebook1->PageIndex ++;
    	Button2->Enabled = true;
    }

    if (Notebook1->PageIndex == Notebook1->Pages->Count - 1)
    {
        Button3->Enabled = false;
        Button4->Enabled = true;
    }
}

Lorsque l'utilisateur clique sur le bouton Suivant, et que l'étape de l'assistant n'est pas la dernière (rappellons que les indices des pages commencent à 0 donc la dernière page est bien égale au nombre de pages moins 1 : Notebook1->Pages->Count - 1), nous incrémentons la valeur de PageIndex et nous activons alors le bouton Précédent. Si la page est la dernière (Notebook1->Pages->Count - 1), nous désactivons le bouton Suivant avec l'instruction Button3->Enabled = false et nous activons le bouton Fin grâce à Button4->Enabled = true. Notez que si la fiche est utilisée comme fiche principale, l'usage de ModalResult n'aura pas d'effet (ce qui est le cas avec la source fournie ci-dessous). La source du programme est jointe : source (3 Ko).

Le menu système est le menu accessible en haut à gauche d'une fenêtre, sous la petite icône. Il est possible de modifier ce menu système. Pour ajouter un élément au menu, deux phases sont nécessaires : tout d'abord, il s'agit d'ajouter un élément au menu système. Ensuite, il faut attribuer un gestionnaire d'événement à cet élément. Voici donc le code qui va créer un nouvel élément de menu :

// Obtention du Handle du menu système
HMENU HandleMenuSysteme = GetSystemMenu(Handle, FALSE);

// Insertion de l'élément dans le menu
AppendMenu(HandleMenuSysteme, MF_STRING, MON_ELEMENT_MENU, "Mon élément personnalisé");

Avec ce code, nous allons ajouter cet élément au menu. Pour cela, nous avons besoin du Handle du menu système (un pointeur sur ce menu). Nous faisons donc appel à la fonction GetSystemMenu. Pour l'ajouter au menu, nous utilisons la fonction AppendMenu, qui ajoute un élément à la fin d'un menu. En premier argument, nous lui passons le Handle du menu système, en second, le type d'élément qui va être rajouté : une chaîne. Notez seulement que le troisième argument est une constante, MON_ELEMENT_MENU, que vous définissez, par exemple dans votre classe fiche :

const int MON_ELEMENT_MENU = 1;

Remarquez que nous aurions pu utiliser également un #define MON_ELEMENT_MENU mais que notre code à l'avantage de s'intégrer totalement dans le C++.

Actuellement, si vous lancez le programme, vous pourrez constater qu'un nouvel élément apparait dans le menu système. Il s'agit maintenant de savoir quand l'utilisateur clique sur cet élément et de gérer ce clic. Pour cela, nous allons créer une fonction-gestionnaire d'événement qui sera appelée lorsque le message WM_SYSCOMMAND sera déclenché par Windows, c'est-à-dire quand l'utilisateur cliquera sur un élément du menu système. Il faut donc déclarer notre fonction comme gestionnaire de message WM_SYSCOMMAND, grâce au code suivant qu'il faut placer dans la classe TForm1, dans la section public :

BEGIN_MESSAGE_MAP
      VCL_MESSAGE_HANDLER(WM_SYSCOMMAND, TMessage, WMCommandeMenuSysteme)
END_MESSAGE_MAP(TForm)

Grâce à ce code, la fonction WMCommandeMenuSysteme sera appelée lorsque l'utilisateur cliquera sur un élément du menu système. Créons donc cette fonction, sans oublier de la déclarer dans le fichier en-tête, le code précédant ne faisant pas office de déclaration :

void TForm1::WMCommandeMenuSysteme(TMessage & Msg)
{
 if (Msg.WParam == MON_ELEMENT_MENU)
   {
      ShowMessage("On a cliqué sur notre élément de menu");
      Msg.Result = true;
   }
   else
   {
      TForm::Dispatch(&Msg);
   }
}

Dans cette fonction, deux cas se présentent : ou le message provient de notre élément menu système et nous devons le gérer, ou c'est un autre élément : dans ce cas, nous passons la main à la fonction Dispatch de la classe TForm afin qu'elle le gère. Si nous oublions ce second cas, seul notre élément fonctionnera. La différentiation des deux cas se fait grâce à notre constante MON_ELEMENT_MENU.

La fonction SetWindowLong permet de changer les attributs d'une fenêtre. Utilisez donc cette fonction, en lui passant le Handle de l'application :

SetWindowLong(Application->Handle, GWL_EXSTYLE, WS_EX_TOOLWINDOW);

Le texte affiché dans la barre des tâches est la chaîne membre Title de la classe TApplication :

Application->Title = "Nouveau titre !";

La classe TApplication comporte une propriété : ShowMainForm, qui permet de ne pas afficher la fiche principale. Il suffit de la positionner à true. Pour cela, éditez le fichier principal du projet et rajoutez la ligne suivante :

		Application->ShowMainForm = false;
		

Vous devez obtenir la fonction WinMain suivante :

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) 
{ 
 try 
 { 
 Application->Initialize(); 
 Application->ShowMainForm = false; // <-- ICI
 Application->CreateForm(__classid(TForm1), &Form1); 
 Application->Run(); 
 } 
 catch (Exception &exception) 
 { 
 Application->ShowException(&exception); 
 } 
 return 0; 
} 

Utilisez le code suivant :

BorderStyle = bsNone; 
Left = 0; 
Top = 0; 
Width = Screen->Width; 
Height = Screen->Height;

BorderStyle = bsNone permet de faire disparaître la barre de titre. Les deux lignes suivantes sont aisémment compréhensibles, n'oubliez pas que nous sommes dans une classe fiche, donc que Left et Top sont les positions de la fiche. Enfin, il suffit de faire coïncider la largeur et la hauteur de la fiche avec celle de l'écran, ce que font nos deux dernières lignes. Bien sûr, ce code se place dans le constructeur de votre fiche, ou dans l'événement OnCreate.
Evitez tout de même de mettre une application qui n'en a pas besoin en plein écran !

Pour cela, utilisez la fonction InputQuery.

AnsiString Chaine;
if (!InputQuery("Titre du livre", "Entrez le titre du livre", Chaine))
      return;
if (!Chaine.Length()) 
      return;

// Recherche du livre
//...       

Ce code demande le titre d'un livre. La fonction InputQuery prend pour argument le texte de la barre de titre, le texte de demande, et la chaîne dans laquelle stocker le résultat. Ainsi, dans ce code, nous ne recherchons le livre que si un titre est entrée et que l'utilisateur valide par Ok . Si l'utilisateur n'entre rien ou clique sur Annuler , le livre ne sera pas recherché.

En relation avec la question précédente, on pourrait souhaiter utiliser le même moyen pour demander un nombre à l'utilisateur. Le problème est que ce dialogue demande une chaîne. On n'a donc aucun contrôle sur la validité du nombre entré. Il faut donc vérifier la valeur entrée et redemander le nombre si ce n'est pas un entier valide :

int TForm1::DemandeEntier()
{
    AnsiString Chaine;
    int Nb;
    bool ReDemande;

    do
    {
        ReDemande = false;
        // On demande le nombre
        if (!InputQuery("Valeur", "Entrez un entier", Chaine))
            return 0; // Si l'utilisateur appuie sur Annuler, on retourne 0
        try
        {
            Nb = StrToInt(Chaine); // On essaie de convertir
        }

        catch(EConvertError &Exception) // Si il y a erreur de conversion
        {
            ReDemande = true; // On doit redemander
        }
    }
    while(ReDemande); // La boucle continue s'il faut redemander

    return Nb; // On retourne le nombre correct
}

Dans cette fonction, on demande une valeur qui est placée dans la chaîne Chaine ( InputQuery("Valeur", "Entrez un entier", Chaine) ) et on teste la valeur de retour. Si cette valeur est NULL, cela signifie que l'utilisateur a appuyé sur Annuler et on retourne la valeur par défaut 0. Sinon, on essaie de convertir la chaîne en entier ( Nb = StrToInt(Chaine) ). Si cela ne réussit pas, une exception est déclenchée qui est rattrapée par le catch(EConvertError &Exception) ou la valeur booléenne ReDemande est positionnée à true . La boucle while ne se termine pas s'il faut redemander la valeur à l'utilisateur. Sinon, le nombre entier est retourné ( return Nb ).

Utilisez la fonction ShellExecute de la manière suivante :

ShellExecute (Handle, "open", "mailto:adresse@provider.ex?subject=Titre_du_message&body=Corps du message", 0, 0, SW_SHOWNORMAL);