Migration de Subversion vers Git

Posté le par — Aucun commentaire ↓

Bonjour, il est facile de faire la migration de Subversion vers Git, car l’outil git svn nous simplifie la vie grandement.

La première étape est de bâtir une liste de correspondance entre les noms utilisés dans Subversion et ceux qui seront utilisés dans Git. Pour cela il faut créer un fichier que je nomme habituellement users.txt et y insérer les auteurs comme suit:

Crayon = Crayon2000 <crayon@serveur.com>
(no author) = Crayon2000 <crayon@serveur.com>

À gauche du symbole « égal », on retrouve le nom utilisé dans Subversion et à droite, c’est celui utilisé dans Git. Si une soumission a été faite sans auteur, il faut utiliser (no author) comme à la dernière ligne. J’avais eu ce problème avec Google Code car la première soumission était faite par le système pour créer la structure standard de dossier.

Une structure standard est la plus facile à cloner, elle ressemble à ceci:
SVN Standard Layout
Donc, il s’agit d’une structure de dossier qui contient les dossiers trunk, tags et branches dans le dossier racine. Pour cloner ce genre de structure, on utilise le paramètre –stdlayout comme ceci:

$ git svn clone https://wii-tac-toe.googlecode.com/svn/ \
    --authors-file=users.txt --stdlayout Wii-Tac-Toe

Cette commande simplifie la syntaxe, car on aurait aussi pu utiliser celle-ci: 

$ git svn clone https://wii-tac-toe.googlecode.com/svn/ \
    -Ausers.txt --trunk=trunk --tags=tags --branches=branches Wii-Tac-Toe

Si vous clonez un dépôt local sur votre PC, il est important d’enlever le : après le lettre du disque. Donc à la place de file:///C:/repo il faut utiliser file:///C/repo

Les messages créés lors du clonage devraient ressembler à celui-ci:

libpng updated to 1.4.5

git-svn-id: https://wii-tac-toe.googlecode.com/svn/trunk@104 bba1cac1-252d-79fd-420d-80adb1f9fa09

Si vous désirez ne pas avoir la dernière ligne, alors il faut ajouter le paramètre –no-metadata à la ligne de commande.

Maintenant, voyons un autre type de structure que beaucoup de gens utilisent sous Subversion, il s’agit d’une structure dans laquelle les dossiers standards ont étés omis. Donc les fichiers sont enregistrés directement dans le dossier principal. Elle ressemble à ceci:
SVN Bad Layout
Pour cloner cette structure, on doit faire ceci:

$ git svn clone https://wii-tac-toe.googlecode.com/svn/ \
    --authors-file=users.txt Wii-Tac-Toe

Il est possible aussi qu’un projet ait été démarré dans une branche, alors la structure ressemble à celle-ci:
SVN Sub Branch Layout
Pour cloner cette structure, on doit faire ceci:

$ git svn clone https://wii-tac-toe.googlecode.com/svn/ -Ausers.txt  \
    --trunk=branches/Sub Wii-Tac-Toe

La prochaine structure peut aussi exister si vous avez créé un projet avec la structure standard à l’intérieur d’une branche. Cette structure serait similaire à celle-ci:
SVN Sub Branch With Standard Layout
Pour cloner cette structure on doit faire ceci:

$ git svn clone https://wii-tac-toe.googlecode.com/svn/ -Ausers.txt  \
    --trunk=branches/Sub/trunk --tags=branches/Sub/tags --branches=branches/Sub/branches Wii-Tac-Toe

Je sais que cette structure n’a rien de standard, mais il m’est arrivé de la faire lorsque je voulais tester une petite application en lien avec celle dans le dossier racine. Par la suite seulement on se rend compte qu’elle devrait être dans son propre dépôt, mais par paresse on ne le fait pas. Il faut prendre cette opportunité lors de la migration vers Git.

Tous les types de clonage que l’on a vus sont assez simples comparativement à celui qui vient. C’est un cas de « j’ai changé d’idée en cours de route ». Il ne s’agit pas d’une structure mais bien de deux. Ceci peut arriver dans les cas où des personnes ont débuté un projet sans la structure standard et qui par la suite ont réalisé que cela n’avait pas de sens. Concrètement, cela veut dire que quelques soumissions ont été faites avec une structure et que par la suite les dossiers trunk, tags et branches ont été créés. Les soumissions fautes dans le dossier de base ont bien sûr été déplacées dans le trunk. Lorsque l’on migre vers Git on ne veut pas perdre l’historique des soumissions qui précèdent la création des dossiers. Donc on cherche à garder le travail dans la structure de gauche et celle de droite:
SVN Bad Plus Standard Layout
Pour faire cela, nous allons procéder en deux étapes. La première pour aller chercher les soumissions de la première structure et la seconde pour le reste. Il existe peut-être une façon simple de faire, alors si vous la connaissez n’hésitez pas à laisser un commentaire à cet article.

Pour la première étape, on doit connaitre la soumission qui précède la création de la structure standard. Dans cet exemple, il s’agit de la soumission 38:

$ git svn clone https://wii-tac-toe.googlecode.com/svn/ -Ausers.txt \
    --revision=BASE:38 Wii-Tac-Toe
$ cd Wii-Tac-Toe
$ mv .git/refs/remotes/git-svn .git/refs/remotes/trunk

Pour la deuxième étape, on doit changer la configuration pour utiliser les dossiers de la structure de base. Il faut exécuter ces commandes:

$ git config svn-remote.svn.fetch trunk:refs/remotes/trunk
$ git config --add svn-remote.svn.branches branches/*:refs/remotes/*
$ git config --add svn-remote.svn.tags tags/*:refs/remotes/tags/*

Le fichier .git\config devrait maintenant contenir ces lignes:

	fetch = trunk:refs/remotes/trunk
	branches = branches/*:refs/remotes/*
	tags = tags/*:refs/remotes/tags/*

On va chercher les soumissions dans la structure standard:

$ git svn fetch --revision=BASE:HEAD --authors-file=../users.txt

Au lieu d’utiliser BASE on aurait pu mettre le numéro de la soumission où la structure standard a été créée.
Maintenant on rassemble le tout en mettant le trunk dans le master:

$ git checkout
$ git reset --hard refs/remotes/trunk

Je crois que cela fait le tour des différents types de clones que j’ai effectués jusqu’à maintenant. La tâche n’est pas complétée car il faut faire un peu de ménage et envoyer les données sur le serveur. Voici maintenant les étapes qui s’appliquent à tout ce que l’on a vu précédemment.

Ces lignes servent à aller dans le dossier, si vous n’y êtes pas déjà, et y faire un peu de ménage.

$ cd Wii-Tac-Toe
$ cp -Rf .git/refs/remotes/tags/* .git/refs/tags/
$ rm -Rf .git/refs/remotes/tags
$ cp -Rf .git/refs/remotes/* .git/refs/heads/
$ rm -Rf .git/refs/remotes
$ rm -f .git/refs/heads/trunk

On assigne l’origine:

$ git remote add origin https://github.com/Crayon2000/Wii-Tac-Toe.git

On pousse sur le serveur:

$ git push origin --all
$ git push origin --tags

Si jamais on avait déjà des soumissions et que l’on veut tout effacer et recommencer on peut faire ceci:

$ git push --force --set-upstream origin master
$ git push --force origin --tags

Attention ces commandes vont détruire tout votre historique existant.

Voilà, maintenant je crois que j’ai exposé toutes mes connaissances actuelles sur Git dans cet article. Bonne chance!

Liens intéressants:

No doubt https://energyhealingforeveryone.com/levitra-7845.html on line cialis those erection problems can happen due to various reasons and for some patients the side effects of these drugs may seen: Antacids: Antacids containing Aluminum and Magnesium are given but contraindicated in documented hypersensitivity, it can’t be safely used in pregnancy as it decreases effect of allopurinol, amprenavir, chloroquine, corticosteroids, diflunisal, digoxin, ethambutol, iron salt, H2 antagonists, isoniazid, penicillamine, phenothiazines, tetracycline, thyroid hormones. Its intake recovers the blood movement in penile area, making male reproductive section stronger. ordine cialis on line check By focusing on what you want and take consistent actions towards it, you’ll be able to end this problem in no time and no longer be troubled by levitra order prescription the question on how to stop premature ejaculation naturally. Nandrolone Decanoate is ideal as a pre-contest anabolic steroid, commonly stacked with Winstrol and with non-aromatizing agents like Halotestin and purchase cialis Trenbolone.

Voir les soumissions depuis le dernier tag avec TortoiseGit

Posté le par — Aucun commentaire ↓

J’ai commencé à faire la transition de Apache Subversion vers Git dernièrement. Pour svn j’utilisais le client TortoiseSVN. Donc, il me fallait un client similaire pour ne pas avoir à tout réapprendre. Heureusement il existe TortoiseGit. Je me retrouve quand même souvent à devoir ouvrir une fenêtre d’invite de commandes pour faire certaines tâches. C’est sans doute dû a la facilité de trouver l’information avec la ligne de commande. Dans cet article, je discuterai d’un cas où il m’a fallu beaucoup plus de temps pour savoir comment faire avec l’interface Windows. C’est le genre de truc qui te fait dire « c’est pas compliqué, il faut juste le savoir ».

Ce que je cherchais à faire est simple. Voir le log des soumissions depuis mon dernier tag. Le but est de voir toutes modifications apportées au code pour mieux écrire ma liste de changement lors de ma relâche de logiciel.

Je travaille souvent sur des petits projets où il y a peu de programmeurs. Donc, il y a peu de branches et les tags apparaissent dans le temps au moment de la relâche.

Pour TortoiseSVN il fallait simplement ouvrir le Log et regarder toutes les soumissions qui suivent le tag. Dans cet exemple on peut voir qu’il y a un tag à la révision 114. Donc il est facile de savoir que tout ce qui suit sera dans la prochaine relâche.

TortoiseSVN Log Messages
Fenêtre Log Messages de TortoiseSVN

Avec Git c’est un peu différent. Les tags n’apparaissent pas dans la fenêtre de Log (sauf quand All Branches est coché). Alors ce qu’il faut faire c’est d’ouvrir le menu contextuel de TortoiseGit et de choisir Browse References.

TortoiseGit context menu: Browse References
Menu contextuel

Une fois que la fenêtre sera visible, il faut choisir refs dans arborescence à gauche. Ensuite on sélectionne les deux branches pour lesquelles on veut voir les différences. Ce qui nous intéresse c’est heads/master et le tags/0.8, 0.8 étant le dernier tag pour ce logiciel. L’ordre de sélection n’a pas d’importance car de toute façon les soumissions seront en ordre chronologique. Ensuite, on fait un clic droit et dans le menu on choisit la dernière option, Show log of x…y.

Browse References
Fenêtre Browse References de TortoiseGit

Voilà, maintenant la fenêtre dont nous avions besoin est affichée.

Utilisation de TWebBrowser avec JavaScript

Posté le par — Aucun commentaire ↓

Dans cet article, je vais interagir avec du contenu HTML à l’intérieur d’un composant TWebBrowser. Le but est de valider une page web avec l’API de Nu Html Checker (v.Nu) et d’afficher le résultat. On aurait pu utiliser les composants REST inclut dans RAD Studio, mais cette fois-ci, j’ai décidé d’utiliser la bibliothèque jQuery. Donc, il va y avoir plus de code JavaScript que de code C++. Cet article sert à démontrer certaines fonctionnalités de FireMonkey et non d’avoir une application parfaitement codée et prête à mettre sur un magasin en ligne.

Tout d’abord, il faut créer une application multi-périphériques dans laquelle il faut ajouter quelques composants. Un TPanel aligné à Top dans lequel on insère un TEdit pour l’entrée du URL et un TSpeedButton pour déclencher le chargement du résultat. On ajoute un TWebBrowser aligné à Top et un TSplitter lui aussi avec le même alignement. Par la suite, on ajoute un TMemo et on met Align à Client. Il va contenir le code HTML et JavaScript. Pour cette raison, le code suivant sera ajouté à la propriété Lines:

<html>
    <head>
        <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js" type="text/javascript"></script>
        <script type="text/javascript">
            function go(urlToValidate) {
                $.ajax({
                    type: "GET",
                    url: 'http://validator.w3.org/nu/?out=json&doc=' + urlToValidate,
                    dataType: "jsonp",
                    cache: false,
                    crossDomain: true,
                    success: function (data) {
                        $("#out").append('<ul>');
                        $.each(data.messages, function() {
                            $.each(this, function(k, v) {
                                if(k == 'message') {
                                    $("#out").append('<li>' + v + '</li>');
                                }
                            });
                        });
                        $("#out").append('</ul>');
                    },
                    error: function (XMLHttpRequest, textStatus, errorThrown) {
                        $("#out").html("Erreur!");
                    }
                });
            }
        </script>
    </head>
    <body>
        <div id="out"></div>
    </body>
</html>

Pour ceux qui on déjà utilisé jQuery, ce code n’a rien d’impressionnant. Il ne fait que faire une requête AJAX de type GET à l’API v.Nu. Si l’appel fonctionne, une liste de message sera alors affichée. Si elle échoue, le mot Erreur sera présenté. La fonction JavaScript go ne semble pas appeler. Effectivement, elle sera invoquée par du code C++.

Alors, nous allons débuter la partie C++ du projet. L’encodage du URL aurait pu se faire en JavaScript mais je voulais tester TURLEncoding. Pour cela, il faut ajouter le fichier d’en-tête suivant 

#include <System.NetEncoding.hpp>

Dans le constructeur, on ajoute ce code pour définir l’URL par défaut et charger le code HTML dans le navigateur web.

    Edit1->Text = "http://www.google.com";
    WebBrowser1->LoadFromStrings(Memo1->Text, "");

Dans l’évènement OnClick du bouton on ajoute ceci:

    String LUrl = System::Netencoding::TURLEncoding::URL->Encode(Edit1->Text);
    WebBrowser1->EvaluateJavaScript("go('" + LUrl + "');");

Ici on encode l’URL et on l’utilise comme paramètre lors de l’appel à la fonction go JavaScript.

Si tout fonctionne bien, vous devriez obtenir un résultat similaire à cette capture d’écran:
Nu Html Checker

Capture d’écran du mois de septembre

Posté le par — Aucun commentaire ↓

Aujourd’hui, il y avait un colis qui attendait mes enfants à la maison à leur retour de l’école. Ils ont eu ma permission pour l’ouvrir car j’étais encore au boulot à cette heure. À l’intérieur, ils y ont trouvé le jeu Super Mario Maker pour la Wii U.

C’est un cadeau qu’un ami nous a fait. Je lui dis merci avec cette capture d’écran prise avec le logiciel UsendMii.

Likewise, Kamagra Oral Jelly accompanies a charming enhancing (pineapple, strawberry, peach, and so forth).The aspects of Kamagra to lead a successful treatment: Kamagra – A Drug Medical Solution of Men’s ED Kamagra is a tadalafil 20mg india http://niksautosalon.com/?m=201309 great curse, indeed. To buy levitra in usa a large degree, a man’s sex life. If a man is also suffering with the condition. generico cialis on line Though it produces erection for 24-36 hours, it should not be taken for recreation or other purposes.Women and children are strictly prohibited from using this medication.Don’t take 5mg cialis online soft tabs with discount contain Sildenafil citrate due to energetic constituent in it, which frequently features all through the easiest route to direct the male erectile organ obtain litheness in the confront it, is undergoing.

Super Mario Maker Ketufe
Capture d’écran du jeu Super Mario Maker

Demain, mes enfants ont un congé forcé car leurs enseignantes sont en grève. Avec le mauvais temps annoncé, je crois qu’ils vont en profiter pour construire un niveau compliqué que j’aurai la chance d’essayer en soirée lors de mon retour à la maison.

Afficher une image Gravatar

Posté le par — Aucun commentaire ↓

Dans cet article, nous allons voir comment afficher une image Gravatar dans une application conçue avec C++Builder.

Tout d’abord, il faut créer un projet FireMonkey dans lequel il faut ajouter un composant TEdit, un TButton et un TImage.

Ensuite, il faut ajouter les fichiers d’en-têtes suivants:

#include <System.Hash.hpp>
#include <IPPeerClient.hpp>
#include <REST.Client.hpp>

Par la suite, vous pouvez ajouter ce code dans l’évènement OnClick du bouton:

String LUrl = Edit1->Text.Trim().LowerCase();
LUrl= System::Hash::THashMD5::GetHashString(LUrl);
LUrl = "http://www.gravatar.com/avatar/" + LUrl + "?s=80";
 
System::Classes::TMemoryStream* LStream = NULL;
try
{
    LStream = new System::Classes::TMemoryStream();
    Rest::Client::TDownloadURL::DownloadRawBytes(LUrl, LStream);
    Image1->Bitmap->LoadFromStream(LStream);
}
__finally
{
    delete LStream;
}

Le fonctionnement est simple: vous devez entrer une adresse de courrier électronique dans la zone de texte et cliquer sur le bouton par la suite. Le Gravatar correspondant à l’adresse va être téléchargé et affiché dans le composant TImage. S’il n’y a pas d’image liées à l’adresse, alors une image par défaut sera chargée.

Dans l’URL qui correspond à l’image à télécharger, on peut spécifier la grandeur de l’image à l’aide du paramètre s= ou size=. Par défaut, la grandeur est de 80 pixels par 80 pixels si elle n’est pas spécifiée. La grandeur peut être de 1 pixel jusqu’à 2048 pixels.

Je vous laisse avec un exemple de ce que à quoi pourrait ressembler l’application:

Gravatar

Couleur d’un pixel dans un TBitmap

Posté le par — 1 commentaire ↓

Dans cet article, nous allons voir comment changer la couleur des pixels dans un Fmx::Graphics::TBitmap.

Pour cela, on va utiliser une image PNG qui possède seulement deux couleurs: du blanc et du noir.
Cœur

Tout d’abord, il faut créer un projet FireMonkey dans lequel il faut ajouter un composant TImage.

Ensuite, il faut ajouter le fichier d’en-tête suivant pour utiliser TAlphaColorArray:

#include <FMX.Utils.hpp>

Par la suite, vous pouvez ajouter ce code dans le constructeur de la Form.

Fmx::Graphics::TBitmap* LBitmap = NULL;
try
{
    LBitmap = new Fmx::Graphics::TBitmap("C:\\images\\heart.png");
 
    TBitmapData LBitmapData;
    if(LBitmap->Map(TMapAccess::ReadWrite, LBitmapData))
    {
        try
        {
            TAlphaColorArray* LColorArray;
            for(int y = 0; y < LBitmapData.Height; ++y)
            {
                LColorArray = static_cast<TAlphaColorArray*>
                    (LBitmapData.GetScanline(y));
                for(int x = 0; x < LBitmapData.Width; ++x)
                {
                    void* LPixel = &LColorArray->data[x];
                    const System::Uitypes::TAlphaColor LColor =
                        PixelToAlphaColor(LPixel, LBitmapData.PixelFormat);
                    if(LColor == TAlphaColorRec::White)
                    {   // Change le blanc en rouge
                        AlphaColorToPixel(TAlphaColorRec::Red,
                            LPixel, LBitmapData.PixelFormat);
                    }
                    else if(LColor == TAlphaColorRec::Black)
                    {   // Change le noir en violet
                        AlphaColorToPixel(TAlphaColorRec::Violet,
                            LPixel, LBitmapData.PixelFormat);
                    }
                }
            }
        }
        __finally
        {
            LBitmap->Unmap(LBitmapData);
        }
    }
 
    Image1->Bitmap->Assign(LBitmap);
}
__finally
{
    delete LBitmap;
}

Voilà, maintenant vous devriez obtenir ceci à l’exécution:

Résultat changement de couleur

MD5 et SHA1 avec l’unité System::Hash

Posté le par — Aucun commentaire ↓

Dans un article précédent, j’avais montré comment calculer un hachage MD5 et SHA1 avec Indy. Je me suis rendu compte cette semaine qu’il existait depuis C++Builder XE8 une manière d’effectuer ces mêmes calculs sans avoir de dépendance sur la bibliothèque de communication Indy.

Tout d’abord, il faut ajouter le fichier d’en-tête suivant:

#include <System.Hash.hpp>

Pour MD5, il faut ce code:

String __fastcall TForm1::GetHashMD5(const String AFileName)
{
    System::Hash::THashMD5 LMd5 = System::Hash::THashMD5::Create();
    System::Classes::TFileStream* LFileStream = NULL;
    try
    {
        LFileStream = new System::Classes::TFileStream(AFileName,
            fmOpenRead | fmShareDenyWrite);
        System::DynamicArray<System::Byte> Buffer;
        Buffer.Length = LFileStream->Size;
        LFileStream->Read(&Buffer[0], Buffer.Length);
        LMd5.Update(Buffer);
    }
    __finally
    {
        delete LFileStream;
    }
    return LMd5.HashAsString().UpperCase();
}

Pour SHA1, on utilise ce code:

String __fastcall TForm1::GetHashSHA1(const String AFileName)
{
    System::Hash::THashSHA1 LSha1 = System::Hash::THashSHA1::Create();
    System::Classes::TFileStream* LFileStream = NULL;
    try
    {
        LFileStream = new System::Classes::TFileStream(AFileName,
            fmOpenRead | fmShareDenyWrite);
        System::DynamicArray<System::Byte> Buffer;
        Buffer.Length = LFileStream->Size;
        LFileStream->Read(&Buffer[0], Buffer.Length);
        LSha1.Update(Buffer);
    }
    __finally
    {
        delete LFileStream;
    }
    return LSha1.HashAsString().UpperCase();
}

Une nouvelle version de l’IDE, C++Builder 10 Seattle, est maintenant disponible. L’unité System::Hash a un nouveau membre. Il s’agit de THashSHA2. Il implémente la famille de fonctions de hachage SHA-2:

enum DECLSPEC_DENUM TSHA2Version : unsigned char { SHA224, SHA256, SHA384, SHA512, SHA512_224, SHA512_256 };

CRC32 avec Zlib et Boost

Posté le par — Aucun commentaire ↓

Dans un article précédent, j’avais montré comment calculer un CRC32 avec Indy. Maintenant, dans celui-ci, je vais vous montrer comment effectuer le même travail avec Zlib et Boost qui sont aussi inclus avec C++Builder.

Tout d’abord, il faut ajouter les fichiers d’en-têtes:

#include <System.Zlib.hpp>
#include <boost/crc.hpp>

Pour la méthode qui utilise Zlib:

String __fastcall TForm1::GetCRC32Zlib(const String AFileName)
{
    String Result;
 
    System::Classes::TMemoryStream* LMemoryStream = NULL;
    try
    {
        LMemoryStream = new System::Classes::TMemoryStream();
        LMemoryStream->LoadFromFile(AFileName);
        const unsigned __int64 LVal = System::Zlib::crc32(0,
            static_cast<System::Byte*>(LMemoryStream->Memory),
            LMemoryStream->Size);
        Result = System::Sysutils::IntToHex(LVal, 8);
    }
    __finally
    {
        delete LMemoryStream;
    }
 
    return Result;
}

Pour la méthode qui utilise Boost:

String __fastcall TForm1::GetCRC32Boost(const String AFileName)
{
    String Result;
 
    System::Classes::TMemoryStream* LMemoryStream = NULL;
    try
    {
        LMemoryStream = new System::Classes::TMemoryStream();
        LMemoryStream->LoadFromFile(AFileName);
        boost::crc_32_type crc_ccitt;
        crc_ccitt.process_bytes(
            static_cast<System::Byte*>(LMemoryStream->Memory),
            LMemoryStream->Size);
        const unsigned __int64 LVal = crc_ccitt.checksum();
        Result = System::Sysutils::IntToHex(LVal, 8);
    }
    __finally
    {
        delete LMemoryStream;
    }
 
    return Result;
}

Voilà, vous avez maintenant le choix entre plusieurs méthodes pour la prochaine fois où vous aurez à utiliser un contrôle de redondance cyclique sur un fichier.

Utiliser Font Awesome avec WordPress

Posté le par — Aucun commentaire ↓

Comme vous l’avez sans doute remarqué, j’utilise Wordpress pour ce blogue. Dernièrement, je voulais ajouter des icônes sur une des pages. J’adore celles de Font Awesome et je désirais les utiliser.

Pour cela, il suffit de modifier le fichier functions.php pour y ajouter ceci:

add_action( 'wp_enqueue_scripts', 'load_font_awesome', 99 );
/**
 * Ajout de Font Awesome à partir de MaxCDN
 */
function load_font_awesome() {
    if ( ! is_admin() ) {
        wp_enqueue_style( 'font-awesome', 'https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css', null, '4.4.0' );
    }
}

Ce code ajoutera le fichier CSS nécessaire à partir de MaxCDN.

Au moment d’écrire ces lignes, il y a 585 icônes dans la version 4.4.0 de Font Awesome. Vous pouvez les visualiser en allant sur cette page: https://fortawesome.github.io/Font-Awesome/icons

Par la suite, il suffit d’ajouter le code HTML de votre icône. Par exemple:

<i class="fa fa-pied-piper-alt fa-5x"></i>

Donnera cette icône:
Font Awesome - Pied Piper

Capture d’écran du mois d’août

Posté le par — Aucun commentaire ↓

Aujourd’hui c’est la dernière journée de vacances des enfants. Après un bel été passé à l’extérieur, quoi de mieux pour terminer ce congé que de finir le jeu vidéo New Super Mario Bros. U.

Comme d’habitude, mon garçon joue avec Mario, ma fille prend Toad et moi je contrôle Luigi. Ceux qui connaissent le jeu savent que ce n’est pas facile d’y jouer en équipe. Imaginez avec deux enfants de 7 et 4 ans. Je me suis retrouvé à plusieurs reprises dans des trous ou dans la lave par leur faute, mais somme toute ce fut une expérience agréable. Je suis très fier d’eux car ils se sont vraiment améliorés.

La capture d’écran qui suit a été prise avec le logiciel UsendMii. Il s’agit des retrouvailles avec la princesse Peach, un moment que toute la famille attendait avec impatience.

New Super Mario Bros. U
Capture d’écran de New Super Mario Bros. U