/// <summary>
        /// Supprime la ligne de Plat/Aliment si l'utilisateur clique sur le bouton
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnControlSupprimer_Click(object sender, RoutedEventArgs e)
        {
            Button  btn        = (Button)sender;
            Plat    monPlat    = new Plat();
            Aliment monAliment = new Aliment();

            bool estPlat = Convert.ToInt32(btn.Uid) > 0;

            // On compte le nbr de plat ou aliment présent dans le plateau pour controller sa suppréssion
            int nbrItemActuel = (estPlat ?
                                 PlateauPlat.Count(P => P.IdPlat == Convert.ToInt32(btn.Uid)) :
                                 PlateauAliment.Count(A => A.IdAliment == Convert.ToInt32(btn.Uid) * -1));
            int iteration = 1;

            if (Keyboard.Modifiers == ModifierKeys.Control)
            {
                iteration = (nbrItemActuel < 10 ?
                             nbrItemActuel :
                             10);
            }

            else if (Keyboard.Modifiers == ModifierKeys.Shift)
            {
                iteration = nbrItemActuel;
            }


            // On supprime 1 / 10 / ou tous le items qui correspondent à l'objet cliqué
            if (estPlat)
            {
                // Si on vide ce plat, il faut enlever son id de la liste des plats à dérouler
                if (nbrItemActuel == iteration)
                {
                    LstIdPlatExplose.Remove(Convert.ToInt32(btn.Uid));
                }
                for (int i = 0; i < iteration; i++)
                {
                    PlateauPlat.Remove(PlateauPlat.Last(P => P.IdPlat == Convert.ToInt32(btn.Uid)));
                }
            }


            else
            {
                for (int i = 0; i < iteration; i++)
                {
                    PlateauAliment.Remove(PlateauAliment.Last(P => P.IdAliment == Convert.ToInt32(btn.Uid) * -1));
                }
            }

            DessinerPlateau();
        }
        /// <summary>
        /// Génere une ligne de plat ou aliment
        /// comportant son nom et son bouton pouvant l'Ajouter ou le supprimer
        /// </summary>
        /// <param name="plus">Parametre qui permet de determiner si la méthode
        /// est appelé pour faire une ligne avec un bouton plus ou un bouton moins</param>
        /// <param name="obj">Plat ou Aliment</param>
        /// <returns></returns>
        Button FormerListeLignePlatAliment(bool?plus, Object obj, List <int?> lstIdPresent)
        {
            // Les plats seront positif et les aliment, négatif

            Plat    plat;
            Aliment aliment;
            Button  btnControl = new Button();


            bool EstPlat = false;


            if (obj.GetType().ToString() == "Nutritia.Plat")
            {
                EstPlat = true;
            }

            // Si c'est un plat que l'on recoit, alors on définnit aliment a null et on crée une instance de plat
            // Sinon, le contraire
            plat    = (EstPlat ? (Plat)obj : null);
            aliment = (!EstPlat ? (Aliment)obj : null);


            // Si la liste est null (On n'apelle pas cette fonction dans le contexte du plateau) alors on rentre dans le bloc
            // Sinon si la liste d'id ne contient pas déja l'id du plat actuelle, alors on rentre pour ajouter ce plat/aliment
            // Sinon, si la liste d'id contient déja l'id du plat actuelle, alors on ne rentre pas car on ne veut pas mettre 2 plats
            // Aussi : Pour les aliments, on utilise le contraire de son id afin de retrouver dans la liste la partie des aliments (id * -1)
            if (lstIdPresent != null ? (!lstIdPresent.Contains((EstPlat ? plat.IdPlat : aliment.IdAliment * -1))) : true)
            {
                // On a pas besoin d'ajouter l'id lorsque le contexte d'apelle n'est pas pour le plateau (Seul place avec un compteur)
                if (lstIdPresent != null)
                {
                    // On définnit que l'on à dessiner le plat
                    if (EstPlat)
                    {
                        lstIdPresent.Add(plat.IdPlat);
                    }
                    else
                    {
                        lstIdPresent.Add(aliment.IdAliment * -1);
                    }
                }

                // Création du bouton pour supprimer ou ajouter un Plat/Aliment
                btnControl.HorizontalContentAlignment = HorizontalAlignment.Left;
                if (plus == null)
                {
                    // On veut un margin pour décaller
                    Thickness margin = btnControl.Margin;
                    margin.Left       = 20;
                    btnControl.Margin = margin;

                    // On ne veut pas pouvoir cliquer sur le bouton
                    btnControl.IsEnabled = false;
                    btnControl.SetValue(ToolTipService.ShowOnDisabledProperty, true);
                }

                btnControl.Height = 32;

                if (plus != null)
                {
                    if ((bool)plus)
                    {
                        btnControl.Click += AjoutItem_Click;
                    }
                    else if ((bool)!plus)
                    {
                        btnControl.Click += BtnControlSupprimer_Click;
                        btnControl.MouseRightButtonDown += BtnControlDerouler_Click;
                    }

                    btnControl.Uid    = (EstPlat ? plat.IdPlat : aliment.IdAliment * -1).ToString();
                    btnControl.Cursor = Cursors.Hand;
                }

                StackPanel stackLigne = new StackPanel();
                stackLigne.Orientation         = Orientation.Horizontal;
                stackLigne.HorizontalAlignment = HorizontalAlignment.Left;
                stackLigne.Width = 275;
                if (plus != null)
                {
                    // Image de bouton
                    Image imgBouton = new Image();
                    imgBouton.Source = new BitmapImage(new Uri("pack://application:,,,/UI/Images/" + ((bool)plus ? "plusIcon" : "minusIcon") + ".png"));
                    imgBouton.Width  = 15;
                    imgBouton.Height = 15;
                    stackLigne.Children.Add(imgBouton);
                }

                // Génération du Label comportant le nom du Plat/Aliment
                Label lblNom = new Label();
                lblNom.FontSize = 12;
                lblNom.Width    = 230;

                if (EstPlat)
                {
                    int nbrMemePlat = PlateauPlat.Count(x => x.IdPlat == plat.IdPlat);
                    // Si on passe null a lstIdPresent, c'est qu'on ne veut pas reproduire ce plat
                    if (lstIdPresent == null)
                    {
                        nbrMemePlat = 0;
                    }
                    lblNom.Content = (nbrMemePlat > 0 && lstIdPresent != null ? nbrMemePlat.ToString() + " " : "") + plat.Nom;
                    stackLigne.Children.Add(lblNom);
                }
                else
                {
                    int nbrMemeAliment = PlateauAliment.Count(x => x.IdAliment == aliment.IdAliment);
                    if (lstIdPresent == null)
                    {
                        nbrMemeAliment = 0;
                    }
                    lblNom.Content = (nbrMemeAliment > 0 ? nbrMemeAliment.ToString() + " " : "") + aliment.Nom;
                    stackLigne.Children.Add(lblNom);
                }

                // Image pour détérminer si c'est un plat ou un aliment
                Image imgTypeElement = new Image();
                imgTypeElement.Source = new BitmapImage(new Uri("pack://application:,,,/UI/Images/" + (EstPlat ? "PlatIcon" : "IngredientsIcon") + ".png"));

                imgTypeElement.Height = 15;
                stackLigne.Children.Add(imgTypeElement);

                // Insertion d'un hover tooltip sur le StackPanel
                if (EstPlat)
                {
                    btnControl.ToolTip = GenererToolTipValeursNutritive(plat);
                }
                else
                {
                    btnControl.ToolTip = GenererToolTipValeursNutritive(aliment);
                }

                btnControl.Content = stackLigne;
            }
            else
            {
                btnControl = null;
            }


            return(btnControl);
        }