Dois-je utiliser un tableau ou une liste

[TazNormand]

.../...
Le seul problème, parce qu'il y en a, ce sont les entrées prévues pour 20 ingrédients qui ne sont pas utilisée, car leur valeur est sauvegardées comme une chaîne vide et une valeur égale à 0.

Peut être il y a-t-il une solution ?

Et bien justement, les listes comme je l'ai dit plus haut te permettent de t'affranchir des 20 ingrédients max, donc tu ne sauves QUE ce qui est saisi et pas plus.

Pour une gestion simple des recettes, JSON ça va encore, mais si tu veux étoffer ton programme pour qu'il te sorte les recettes utilisant un ingrédient particulier, je te conseille fortement de passer à une base de données SQL.

Comme te l'as demandé Falsam, comment sauves-tu tes recettes ?

[Micoute]

En fait, je sauvegarde le contenu de mes gadgets, même ceux qui sont vides, et c'est là mon problème.

Je ne vois pas comment faire autrement, le fichier d'aide de PB n'est pas très explicite sur ce sujet.

[TazNormand]

En fait il faudrait que tes gadgets soient également gérés par une liste chaînée. Pour gérer ta sauvegarde, il te suffit de vérifier si le gadget est vide.

Perso, je n'ajouterai pas la possibilité de saisir les 20 ingrédients tout de suite, mais plutôt gérer l'ajout via un bouton ou à chaque fois que tu saisis un ingrédient. Comme ça tu sais combien d'ingrédients (=élément de la liste chainée) tu as à sauvegarder.

[Micoute]

Si je comprends bien ce que tu me dis, le mieux serait d'ajouter une structure ou j'aurais la quantité d'ingrédient et le nom de l'ingrédient, et dans la deuxième structure, j'aurais le nom de la recette dans un StringGadget, la préparation de la recette dans un EditorGadget, le nombre de personnes pour laquelle est prévue la recette en vue de la recalculer plus tard et un liste chaînée structurée avec la structure précedante.

la première structure serait:

Code : Tout sélectionner

Structure Ingredient
  Quantite.f[20]
  Aliment.s[20]
EndStructure  

et la seconde:

Code : Tout sélectionner

Structure Recette
  Nom.s
  Preparation.s
  Nb_Pers.i
  List Ing.Ingredient()
EndStructure

Le problème, c'est est-ce que je saurai gérer ça ?

[falsam]

@Micoute : Pourquoi tu persistes à bloquer le nombre d'ingrédients ?

Le principe est qu'une recette est lié à 0 -> N Ingrédients

- Structure d'une ligne d'ingrédient.

Code : Tout sélectionner

Structure Ingredient 
  Quantite.s
  Unite.i 
  Ingredient.s  
EndStructure

J'ai ajouté unité pour exprimer (g, Kg, Cl, Litre, etc ....)

- Structure d'une recette.

Code : Tout sélectionner

Structure Recette 
  Nom.s
  List Ingredients.Ingredient() ;(0 à N ingrédient)
  Preparation.s
  Nb_Pers.s
EndStructure
Global NewList Recettes.Recette()

De cette maniére tu n'as plus à te soucier du nombre d'ingrédients à sauvegarder.

[Micoute]

Tu as bien raison, car je suis complètement embourbé dans mon logiciel, avec toi ça paraît tellement simple, je crois que je vais tout reprendre à la base.

[falsam]

Pour le plaisir de tester la faisabilité de ce que j'ai dit précédemment, j'ai préparé un code. Si tu le souhaite je peux le publier.

[TazNormand]

J'avais commencé à préparer un message du même type que Falsam, mais j'ai été pris par autre chose, bref.
Je nuancerai les propos de Falsam par le fait qu'une recette a au moins 1 ingrédient, doc 1-->N, car des recettes sans ingrédient, bah ce ne sont pas des recettes.

Si tu ne veux pas te prendre trop la tête à tout reprendre, et pour faciliter l'ajout d'ingrédient, ajouter un bouton "+" au niveau du gadget ingrédient afin d'en ajouter un nouveau à la suite., et pour la sauvegarde, et bien si les gadgets "ingrédient, qté et unité" sont vide, et bien tu n'enregistres pas la valeur nulle, tu fais ça pour tous les ingrédients, ce qui fait que même si une ligne vide (ingrédient ajouté mais valeurs laissées à vide), dans ton fichier JSON ou ta base de données, tu ne sauveras que les valeurs saisies.

Imaginons que l'utilisateur ait cliqué 5 fois sur le bouton "+" pour ajouter des gadgets "ingrédients", si les valeurs saisies dans ces gadgets sont :
{{Lait,0.5,litre},{farine,250,grammes},{vide,vide,vide},{oeufs,3,unité},{vide,vide,vide},{ananas,500,grammes}}

En faisant le test du "vide", on JSON ou ta base de données recevront :
{{Lait,0.5,litre},{farine,250,grammes},{oeufs,3,unité},{ananas,500,grammes}}

L'utilisateur aura créé 6 gadgets ou si tu préfères 6 ingrédients, mais on en aura sauvé que 4 utiles.

[Micoute]

finalement avec mon nouveau programme, je remplace tous mes StringGadget qui servent à énumérer les ingrédients et leurs quantités par un EditorGadget, comme ça plus besoin de rajouter une liste dans la liste, mais ce n'est pas une bonne solution, car mes recettes ne sont plus proportionnables, qu'est-ce que je pourrais donner pour avoir la solution, étant donné que je ne possède rien.

[falsam]

qu'est-ce que je pourrais donner pour avoir la solution, étant donné que je ne possède rien.

Je ne sais pas si c'est la solution, mais voici mon code.

Je ne me suis pas attaché à la présentation car je souhaitais juste tester la faisabilité des propos que j'ai tenus hier.

Quelques mots sur ce code.

- A la première utilisation une nouvelle recette est mise en place. Il est donc inutile de cliquer sur le bouton Nouveau.
- Le bouton Sauvegarder sauvegarde la recette dans la liste des recettes et non pas dans un fichier.
- le bouton Supprimer supprime une recette.
- Tu peux mettre autant d'ingrédients que tu souhaites.

- Les recettes sont sauvegarder dans un fichier JSON quand on quitte l'application.

Code : Tout sélectionner

Procedure RecettesSave()
  CreateJSON(#JSONFile)    
  InsertJSONList(JSONValue(#JSONFile), Recettes())
  SaveJSON(#JSONFile, "Recettes.json")
  ProcedureReturn #True
EndProcedure

Tu remarquera la simplicité de cette sauvegarde qui se résume à un simple transfert de la liste vers le fichier JSON.
Un autre avantage, est la possibilité de modifier la structure des recettes sans perdre les recettes précédentes.

- A l'ouverture de l'application, l'importation crée une sauvegarde de sécurité. Si tu as fais une bêtise dans les recettes, quitte l'application, supprime le fichier "recettes.json" et renomme "recettes.old.json" en "recettes.json".

■ Et maintenant le code

Code : Tout sélectionner

EnableExplicit

Enumeration Fichier
  #JSONFile
EndEnumeration

Enumeration Window
  #mf
EndEnumeration

Enumeration Gadgets
  #ListRecettes
  
  #Nom
  #NbPers
  #Preparation
  
  #ListIngredients        
  #IngredientNouveau
  
  ;Mise à jour des recettes
  #Nouveau            ;Nouvelle recette
  #Supprimer          ;Supprimer une recette
  #Sauvegarder        ;Sauvegarder une recette
EndEnumeration

;Nombre de Gadgets Par Ligne d'Ingrédient
#NGPLI = 4

;Recettes 
Structure Ingredient ;Ligne d'ingrédient
  Quantite.s
  Unite.i
  Ingredient.s  
EndStructure

Structure Recette   ;Recette
  Nom.s
  List Ingredients.Ingredient() ;(0 à N ingrédient)
  Preparation.s
  Nb_Pers.s
EndStructure
Global NewList Recettes.Recette()

;Gadgets utilisés par chaque ligne d'ingredient
; Une ligne de gadget est composé d'un tableau de x Gadgets
; Dans cette exemple il y a 4 Gadgets (Quantite + Unite + Ingredient + Bouton suppression d'un indgrédient)
Structure LigneIngredient
  Array Ingredients.i(#NGPLI-1)
EndStructure
Global NewList ListeIngredients.LigneIngredient()

Global Lig = 10, TokenNouveau.b

;Plan de l'application
Declare Start()             ;Affichage de l'application

Declare RecettesListe()       ;Liste des recettes
Declare RecetteSelect()       ;Sélectionner une recette
Declare RecetteClear()        ;Reset d'une recette (Clear de l'ensemble des éléments)
Declare RecetteSupprime()     ;Supprimer une recette
Declare RecetteSave()         ;Sauvegarde d'une recette

Declare IngredientNouveau()   ;Ajouter une nouvelle ligne d'ingrédient
Declare IngredientSupprime()  ;Supprimer une ligne d'ingrédient

;Chargement et sauvegarde des données 
Declare RecettesCharge()    
Declare RecettesSave()

Declare Exit()

Start()

Procedure Start()
  OpenWindow(#mf, 0, 0, 800, 600, "Recettes de cuisine", #PB_Window_SystemMenu|#PB_Window_ScreenCentered)
  
  ;Liste des recettes
  TextGadget(#PB_Any, 10, 10, 200, 22, "Liste des recettes")
  ListViewGadget(#ListRecettes, 10, 30, 780, 150)
  
  ;Recette
  TextGadget(#PB_Any, 10, 200, 100, 22, "Nom")
  StringGadget(#Nom, 120, 200, 400, 22, "")
  
  TextGadget(#PB_Any, 10, 230, 100, 22, "Nombre de personne")
  StringGadget(#NbPers, 120, 230, 400, 22, "4", #PB_String_Numeric)
  
  TextGadget(#PB_Any, 10, 270, 100, 20, "Préparation")
  EditorGadget(#Preparation, 10, 292, 780, 100, #PB_Editor_WordWrap)
  
  ScrollAreaGadget(#ListIngredients, 10, 410, 780, 150, 750, 1000)
  CloseGadgetList()
  ButtonGadget(#IngredientNouveau, 10, 565, 780, 24, "Ajouter un ingrédient")
  
  ButtonGadget(#Nouveau, 700, 200, 90, 24, "Nouveau")
  ButtonGadget(#Supprimer, 700, 230, 90, 24, "Supprimer")
  DisableGadget(#Supprimer, #True)
  ButtonGadget(#Sauvegarder, 700, 260, 90, 24, "Sauvegarder")  
  
  ;Declencheur Gadgets
  BindGadgetEvent(#ListRecettes, @RecetteSelect())
  BindGadgetEvent(#IngredientNouveau, @IngredientNouveau())
  
  BindGadgetEvent(#Nouveau, @RecetteClear())
  BindGadgetEvent(#Supprimer, @RecetteSupprime())
  BindGadgetEvent(#Sauvegarder, @RecetteSave())
  
  ;Déclencheur Window
  BindEvent(#PB_Event_CloseWindow, @Exit())
  
  ;Affichage des recettes et sélection de la recette 1
  If RecettesCharge()
    RecettesListe()
    SetGadgetState(#ListRecettes, 0)
    RecetteSelect()
  EndIf 
  
  Repeat : WaitWindowEvent() : ForEver
EndProcedure

;-
;- Recettes
Procedure RecettesListe()
  ClearGadgetItems(#ListRecettes)
  SortStructuredList(Recettes(), #PB_Sort_Ascending , OffsetOf(Recette\Nom), TypeOf(Recette\Nom))
  ForEach Recettes()
    AddGadgetItem(#ListRecettes, -1, Recettes()\Nom)
  Next
  If ListSize(Recettes()) = 0
    TokenNouveau = #True
    IngredientNouveau()
  EndIf
EndProcedure

Procedure RecetteSelect()
  Protected Index = GetGadgetState(#ListRecettes)
  
  If Index <> -1
    RecetteClear() ;Effacer les élements de la recette précédente
    
    SelectElement(Recettes(), Index) 
    
    With Recettes()
      SetGadgetText(#Nom, \Nom)
      SetGadgetText(#NbPers, \Nb_Pers)
      SetGadgetText(#Preparation, \Preparation)
      
      ForEach Recettes()\Ingredients()
        IngredientNouveau()
        SetGadgetText(ListeIngredients()\Ingredients(0), \Ingredients()\Quantite)
        SetGadgetState(ListeIngredients()\Ingredients(1), \Ingredients()\Unite)        
        SetGadgetText(ListeIngredients()\Ingredients(2), \Ingredients()\Ingredient)
      Next  
    EndWith
    
    TokenNouveau = #False
    DisableGadget(#Supprimer, #False)
  EndIf 
EndProcedure

;Mise en place d'une nouvelle recette
Procedure RecetteClear()
  Protected n, Gadget
  
  SetGadgetText(#Nom, "")
  SetGadgetText(#NbPers, "4")
  SetGadgetText(#Preparation, "")
  
  ;Supression des lignes d'ingredient de l'ancienne recette si necessaire
  ForEach ListeIngredients()
    With ListeIngredients()
      UnbindGadgetEvent(\Ingredients(3), @IngredientSupprime(), #PB_EventType_LeftClick)
      For n = 0 To #NGPLI-1
        FreeGadget(\Ingredients(n))
      Next  
    EndWith
  Next
  ClearList(ListeIngredients())
  
  ;Mise en place d'une nouvelle ligne d'ingredient 
  Lig = 10  
  If EventGadget() = #Nouveau
    IngredientNouveau()
    TokenNouveau = #True
    DisableGadget(#Supprimer, #True)
  EndIf
EndProcedure

;Suppression d'une recette 
Procedure RecetteSupprime()
  SelectElement(Recettes(),ListIndex(Recettes()))
  DeleteElement(Recettes())
  RecetteClear()
  RecettesListe()
  SetGadgetState(#ListRecettes, 0)
  RecetteSelect()
EndProcedure

Procedure RecetteSave()
  Protected Buffer.s
  
  ;Controle de cohérence
  ; - Nom de la recette obligatoire
  If Trim(GetGadgetText(#Nom)) <> ""
    
    If TokenNouveau = #True
      AddElement(Recettes())
    Else
      ;C'est une modification : Suppression des anciens ingrédients
      ForEach Recettes()\Ingredients()
        DeleteElement(Recettes()\Ingredients())
      Next
    EndIf
    
    ;Tronc commun à la création et la modification de recettes
    
    ;1er lettre du nom de la recette en majuscule 
    Buffer = GetGadgetText(#Nom)
    Buffer = UCase(LSet(Buffer, 1)) + Mid(Buffer, 2)
    SetGadgetText(#Nom, Buffer) 
    
    With Recettes()
      \Nom = GetGadgetText(#Nom)
      \Nb_Pers = GetGadgetText(#NbPers)
      \Preparation = GetGadgetText(#Preparation)
      
      ForEach ListeIngredients()
        AddElement(Recettes()\Ingredients())
        Recettes()\Ingredients()\Quantite   = GetGadgetText(ListeIngredients()\Ingredients(0))
        Recettes()\Ingredients()\Unite      = GetGadgetState(ListeIngredients()\Ingredients(1))
        Recettes()\Ingredients()\Ingredient = GetGadgetText(ListeIngredients()\Ingredients(2))
      Next
    EndWith
    TokenNouveau = #False
    RecettesListe()
    SetGadgetState(#ListRecettes, ListIndex(Recettes()))
    RecetteSelect()
    
  Else
    
    MessageRequester("Information", "Avant de sauvegarder, donner un titre à la recette")
  EndIf  
EndProcedure

;-
;- Ingrédients (Création et suppression)
Procedure IngredientNouveau()
  OpenGadgetList(#ListIngredients)
  
  AddElement(ListeIngredients())
  With ListeIngredients()
    
    ;Quantité
    \Ingredients(0) = StringGadget(#PB_Any, 10, Lig, 50, 22, "1", #PB_String_Numeric)
    
    ;Unité de mesure
    \Ingredients(1) = ComboBoxGadget(#PB_Any, 65, Lig, 70, 22)  
    AddGadgetItem(\Ingredients(1), -1, "")
    AddGadgetItem(\Ingredients(1), -1, "Gramme")
    AddGadgetItem(\Ingredients(1), -1, "kg")
    AddGadgetItem(\Ingredients(1), -1, "cl")
    AddGadgetItem(\Ingredients(1), -1, "Litre")
    AddGadgetItem(\Ingredients(1), -1, "Pincée")
    AddGadgetItem(\Ingredients(1), -1, "Cuillére")
    AddGadgetItem(\Ingredients(1), -1, "Verre")
    AddGadgetItem(\Ingredients(1), -1, "Feuille")
    AddGadgetItem(\Ingredients(1), -1, "Bouquet")
    AddGadgetItem(\Ingredients(1), -1, "Cube")
    AddGadgetItem(\Ingredients(1), -1, "Quart")  
    AddGadgetItem(\Ingredients(1), -1, "Demie")
    
    ;Ingrédient
    \Ingredients(2) = StringGadget(#PB_Any, 140, Lig, 570, 22, "")
    
    ;Bouton suppression
    \Ingredients(3) = ButtonGadget(#PB_Any, 725, Lig, 22, 22, "-")
    
    ;le bouton suppression mémorise l'index 
    SetGadgetData(\Ingredients(3), ListIndex(ListeIngredients()))
    BindGadgetEvent(\Ingredients(3), @IngredientSupprime(), #PB_EventType_LeftClick)
  EndWith
  CloseGadgetList()
  Lig + 30
EndProcedure

Procedure IngredientSupprime()
  Protected Gadget, Index, n 
  
  ;Quel est le bouton suppression qui a provoquer l'evenement
  Gadget = EventGadget()
  
  ;Selection de la ligne à supprimer  
  Index = GetGadgetData(Gadget)
  
  ;Suppression de la ligne 
  If SelectElement(ListeIngredients(), Index)
    With ListeIngredients()
      UnbindGadgetEvent(\Ingredients(3), @IngredientSupprime(), #PB_EventType_LeftClick)    
      For n = 0 To #NGPLI-1
        FreeGadget(\Ingredients(n))
      Next  
    EndWith 
    DeleteElement(ListeIngredients())
    
    ;Re-Numerotation des lignes 
    Lig = 10
    ForEach ListeIngredients()
      With ListeIngredients()
        ResizeGadget(\Ingredients(0), 10, Lig, #PB_Ignore, #PB_Ignore)
        ResizeGadget(\Ingredients(1), 65, Lig, #PB_Ignore, #PB_Ignore)
        ResizeGadget(\Ingredients(2), 120, Lig, #PB_Ignore, #PB_Ignore)
        ResizeGadget(\Ingredients(3), 725, Lig, #PB_Ignore, #PB_Ignore)
        SetGadgetData(\Ingredients(3), ListIndex(ListeIngredients()))        
        Lig + 30
      EndWith 
    Next
  EndIf
EndProcedure

;-
;- Chargement et sauvegarde des recettes 
Procedure RecettesCharge()
  
  ;Copie de sécurité
  If FileSize("recettes.json") <> -1
    CopyFile("recettes.json", "recettes.old.json")
  Else
    ;Récupération du fichier de sécurité si existant
    If FileSize("recettes.old.json") <> -1
      CopyFile("recettes.old.json", "recettes.json")
    EndIf
  EndIf
    
  ;Chargement des recettes
  If LoadJSON(#JSONFile, "recettes.json")    
    ExtractJSONList(JSONValue(#JSONFile), Recettes())        
  EndIf  
  ProcedureReturn #True
EndProcedure

Procedure RecettesSave()
  CreateJSON(#JSONFile)    
  InsertJSONList(JSONValue(#JSONFile), Recettes())
  SaveJSON(#JSONFile, "Recettes.json")
  ProcedureReturn #True
EndProcedure

;-
;- Sortie avec sauvegarde des recettes
Procedure Exit()
  If RecettesSave()
    End
  EndIf
EndProcedure

[Micoute]

Merci énormément falsam, ce programme est vraiment génial et correspond totalement avec ce que je voulais faire, mais je m'étais tellement embrouillé en partant dans la mauvaise direction que je m'étais éloigné des lumières du savoir. Mais pourquoi je n'arrive plus à faire ce que je veux quand il y a plus de sept variables ? Je suis obligé de les afficher sur mon second écran.

[falsam]

Mais pourquoi je n'arrive plus à faire ce que je veux quand il y a plus de sept variables ? Je suis obligé de les afficher sur mon second écran.

Je ne comprend pas le sens de ta phrase.

[Marc56]

Considérer un tableau comme un livre blanc avec des pages numérotés et une liste comme une pile de feuilles

Le livre (Dim):
- On peut atteindre n'importe quelle page par son numéro
- On peut arracher une page (vider), mais il reste un bout (numéro)
- On peut coller des pages à la fin (redim)
- On peut couper la fin (redim)

La pile de feuilles (List()):
- On peut ajouter autant de pages qu'on veut n'importe où dans la pile InsertElement()
- On peut en supprimer autant qu'on veut n'importe où DeleteElement()
- On peut aller au début, à la fin
- On peut la vider ClearList() ou la supprimer FreeList()
- On connait le nombre d'élements ListSize()
- On peut les lire une par une en avant ou en arrière NextElement(), PreviousElement
- On peut trier SortList(), SortStructuredList()
- On peut tout mélanger RandomizeList()
- On peut faire subir un même traitement à tous les éléments ForEach
- On sait où est le marque-page à tout moment ListIndex()
- On peut atteindre une page directement SelectElement(),
sachant que son numéro est refait à chaque changement
(comme les numéros de ligne d'un tableur)

Quand on a un nombre d’éléments inconnus, la liste est idéale.
(habitué depuis plus de 30 ans aux tableaux, j'ai eut du mal au début avec les listes, mais c'est vachement bien)

[Micoute]

Mais pourquoi je n'arrive plus à faire ce que je veux quand il y a plus de sept variables ? Je suis obligé de les afficher sur mon second écran.

Je ne comprend pas le sens de ta phrase.

Je veux dire que j'ai tellement peu de mémoire que je ne peux retenir au maximum 7 variables sinon je les copie dans un éditeur de texte que j'affiche sur mon deuxième moniteur, c'est dire à quel point je suis limité, mais j'ai été bien pire.

[Mouillard]

Bonsoir à tous,

Pour ma part bravo à Micoute pour l'idée Recettes de cuisine.

Et bravo également à Falsam pour ce code très bien fait, comme on dit" Au pied levé".

Je me servirai de ce code ///

G juste modifié les lignes 90 à 92 pour pouvoir faire des copier/coller de recettes (2 lignes du code Minilib de Zaphod du 10/2017) merci à lui aussi....

Code : Tout sélectionner

 ;=================================================================================================================================================================================
  ;TextGadget(#PB_Any, 10, 270, 100, 20, "Préparation")
  ;EditorGadget(#Preparation, 10, 292, 780, 100, #PB_Editor_WordWrap)                            ;ICI ReadOnly  ==>  #PB_Editor_WordWrap    EditorGadget
  ; StringGadget(#Preparation, 10, 292, 780, 100, "")
  
   FrameGadget(#Frame_3, 10, 260, 100, 30, "Préparation")
   StringGadget(#Preparation, 10, 292, 880, 200, "", #ES_MULTILINE|#WS_BORDER|#WS_VSCROLL|#WS_HSCROLL)                                 ;ICI  était #String_edit code Minilib de Zaphod
 ;=====================================================================================================================================================================================