PureBasic

Code : Tout sélectionner

; Lire un fichier a la vitesse de l'éclair
; Par M Dieppedalle David le dimanche 3 octobre 2010

file$ = OpenFileRequester("Sélectionnez un fichier","","Text (.txt)|*.txt|All files (*.*)|*.*",0)
  If file$
    If ReadFile(0, file$)
      length = Lof(0) ; Lit la taille en octets du fichier
      *MemoryID = AllocateMemory(length) ; alloue un bloc mémoire de la taille du fichier "length"
      If *MemoryID ; si l'allacation a bien fonctionner ont continue
        ReadData(0, *MemoryID, length)   ; Lit les données du fichier et les place dans le bloc mémoire "*MemoryID" de la taille correspondant à "length"
        *Fichier.String = @*MemoryID ; "*Fichier" a pour valeur l'adresse où réside la chaîne de caractères en mémoire "*MemoryID"
        Fichier$ = *Fichier\s ; "Fichier$" à pour valeur le texte où réside la chaîne de caractères en mémoire "*MemoryID"
        Debug Fichier$
      EndIf
      CloseFile(0)
    EndIf
  EndIf

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l WriteFileLigne(NonFichier$, Texte$, NumeroLigne, Position) ; Position -1 = écrire a la fin de la ligne
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  Debug Position
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      Ligne$ = ComptenueFichier()
      If Position = -1
        Position = Len(Ligne$) + 1
      ElseIf Position <= 0
        Position = 1
      ElseIf Position > Len(Ligne$)
        Position = Len(Ligne$)
      EndIf
      Ligne$ = InsertString(Ligne$, Texte$, Position)
      ComptenueFichier() = Ligne$
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteStringN(1, ComptenueFichier())
      Next ComptenueFichier()
      CloseFile(1)
    Else
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NombreLigne = 0

Procedure CountFileLine(NonFichier$)
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      ReadString(1) ; lit ligne par ligne le contenu du fichier
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    MessageRequester("Information","Impossible d'ouvrir le fichier !")
  EndIf
EndProcedure

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l DeleteFileLigne(NonFichier$, NumeroLigne)
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) + Chr(13) + Chr(10) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      DeleteElement(ComptenueFichier(), 1)
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteString(1, ComptenueFichier())
      Next ComptenueFichier()
      
      CloseFile(1)
    Else ; Sinon ont affiche un message d'avertissement
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l RemoveCharFileLigne(NonFichier$, ChaineASupprimer$, NumeroLigne, Position, Mode, SupprimerNombreOccurence) ; Position -1 = supprimer le dernier caractère a la fin de la ligne
  
  If Mode = 0
    Mode = #PB_String_NoCase
  ElseIf Mode = 1
    Mode = 0
  Else
    Mode = #PB_String_NoCase
  EndIf
  
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      Ligne$ = ComptenueFichier()
      If Position = -1
        Position = Len(Ligne$)
      ElseIf Position <= 0
        Position = 1
      ElseIf Position > Len(Ligne$)
        Position = Len(Ligne$)
      EndIf
      Ligne$ = RemoveString(Ligne$, ChaineASupprimer$, Mode, Position, SupprimerNombreOccurence)
      ComptenueFichier() = Ligne$
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteStringN(1, ComptenueFichier())
      Next ComptenueFichier()
      CloseFile(1)
    Else
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l ReplaceCharFileLigne(NonFichier$, ChaineARechercher$, RemplacerChainePar$, NumeroLigne, PositionDepart, Mode) ; Position -1 = Remplacer le dernier caractère a la fin de la ligne
  
  If Mode = 0
    Mode = #PB_String_NoCase
  ElseIf Mode = 1
    Mode = 0
  Else
    Mode = #PB_String_NoCase
  EndIf
  
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      Ligne$ = ComptenueFichier()
      If Position = -1
        Position = Len(Ligne$)
      ElseIf Position <= 0
        Position = 1
      ElseIf Position > Len(Ligne$)
        Position = Len(Ligne$)
      EndIf
      Ligne$ = ReplaceString(Ligne$, ChaineARechercher$, RemplacerChainePar$, Mode, Position)
      ComptenueFichier() = Ligne$
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteStringN(1, ComptenueFichier())
      Next ComptenueFichier()
      CloseFile(1)
    Else
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Code : Tout sélectionner

Global NewList Fichier.s()
Global NombreLigne = 0

Procedure.l FileOperation(NomFichier$ = "", TypeOperation$ = "", NumeroLigne = 1, Chaine1$ = "", Chaine2$ = "", Position = 1, Mode = 0, Occurence = 1)
  
  ClearList(Fichier())
  
  If TypeOperation$ = "ReadSimple"
    
    If ReadFile(1, NomFichier$) ; Si le fichier peut être lu , on continue...
      While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File') 
        AddElement(Fichier())
        Fichier() = ReadString(1) ; Affiche ligne par ligne le contenu du fichier
      Wend
      CloseFile(1) ; Ferme le fichier précédemment ouvert
      ProcedureReturn 1
    Else ; Sinon ont affiche un message d'avertissement
      ProcedureReturn 0
    EndIf
    
  ElseIf NomFichier$ = "ReadSpeed"
    ; Lire un fichier a la vitesse de l'éclair
    ; Par M Dieppedalle David le dimanche 3 octobre 2010
    Ligne = 0
        If ReadFile(1, file$) 
          length = Lof(1) ; Lit la taille en octets du fichier 
          *MemoryID = AllocateMemory(length) ; alloue un bloc mémoire de la taille du fichier "length"
          If *MemoryID ; si l'allacation a bien fonctionner ont continue
            ReadData(1, *MemoryID, length)   ; Lit les données du fichier et les place dans le bloc mémoire "*MemoryID" de la taille correspondant à "length"
            *Fichier.String = @*MemoryID ; "*Fichier" a pour valeur l'adresse où réside la chaîne de caractères en mémoire "*MemoryID"
            Donnee$ = *Fichier\s ; "Fichier$" à pour valeur le texte où réside la chaîne de caractères en mémoire "*MemoryID"
            
            Repeat
              Ligne + 1
              AddElement(Fichier())
              Fichier() = StringField(Donnee$, Ligne, Chr(13) + Chr(10))
            Until Lecture$ = ""
            
            ProcedureReturn 1
          Else
            ProcedureReturn 0
          EndIf
          CloseFile(0)
        Else
          ProcedureReturn 0
        EndIf
      
    ElseIf NomFichier$ = "WriteSimple"
      If OpenFile(1, NomFichier$)    ; Ouvre un fichier existant ou en crée un nouveau s'il n'existait pas
        FileSeek(1, Lof(1))         ; Place le pointeur à la fin du fichier en utilisant le résultat de Lof() 
        WriteStringN(1, Chaine1$)
        CloseFile(1)
        ProcedureReturn 1
      Else ; Sinon ont affiche un message d'avertissement
        ProcedureReturn 0
      EndIf
      
    ElseIf NomFichier$ = "WriteStringLine"
      
      ; Position -1 = écrire a la fin de la ligne
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        Debug Position
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            Ligne$ = Fichier()
            If Position = -1
              Position = Len(Ligne$) + 1
            ElseIf Position <= 0
              Position = 1
            ElseIf Position > Len(Ligne$)
              Position = Len(Ligne$)
            EndIf
            Ligne$ = InsertString(Ligne$, Chaine1$, Position)
            Fichier() = Ligne$
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteStringN(1, Fichier())
            Next Fichier()
            CloseFile(1)
          Else
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
      
    ElseIf NomFichier$ = "CountLine"
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            ReadString(1) ; lit ligne par ligne le contenu du fichier
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
          ProcedureReturn 1
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
    ElseIf NomFichier$ = "RemoveLine"
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) + Chr(13) + Chr(10) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            DeleteElement(Fichier(), 1)
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteString(1, Fichier())
            Next Fichier()
            
            CloseFile(1)
          Else ; Sinon ont affiche un message d'avertissement
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
      
    ElseIf NomFichier$ = "RemoveStringLine"
      ; Position -1 = supprimer le dernier caractère a la fin de la ligne
        If Mode = 0
          Mode = #PB_String_NoCase
        ElseIf Mode = 1
          Mode = 0
        Else
          Mode = #PB_String_NoCase
        EndIf
        
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            Ligne$ = Fichier()
            If Position = -1
              Position = Len(Ligne$)
            ElseIf Position <= 0
              Position = 1
            ElseIf Position > Len(Ligne$)
              Position = Len(Ligne$)
            EndIf
            Ligne$ = RemoveString(Ligne$, Chaine1$, Mode, Position, Occurence)
            Fichier() = Ligne$
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteStringN(1, Fichier())
            Next Fichier()
            CloseFile(1)
          Else
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
      
    ElseIf NomFichier$ = "ReplaceStringLine"
      ; Par M Dieppedalle David en avril  2011
      ; Position -1 = Remplacer le dernier caractère a la fin de la ligne
        
        If Mode = 0
          Mode = #PB_String_NoCase
        ElseIf Mode = 1
          Mode = 0
        Else
          Mode = #PB_String_NoCase
        EndIf
        
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            Ligne$ = Fichier()
            If Position = -1
              Position = Len(Ligne$)
            ElseIf Position <= 0
              Position = 1
            ElseIf Position > Len(Ligne$)
              Position = Len(Ligne$)
            EndIf
            Ligne$ = ReplaceString(Ligne$, Chaine1$, Chaine2$, Mode, Position)
            Fichier() = Ligne$
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteStringN(1, Fichier())
            Next Fichier()
            CloseFile(1)
          Else
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
           
    Else
      
    EndIf
    
  EndProcedure
  
; IDE Options = PureBasic 4.60 Beta 2 (Windows - x86)
; CursorPosition = 8
; Folding = -
; EnableXP
; EnableUser
; EnableOnError
; EnableCompileCount = 11
; EnableBuildCount = 0
; EnableExeConstant

Code : Tout sélectionner

; textfile.pbi
; ce module permet de créer un objet pour manipuler rapidement des fichiers textes.
; explication pour mieux comprendre ce code.
; notre objet peut être assimilé à une boîte dans laquelle on utilise la procédure "textfile_new" pour introduir le / les fichiers *.txt à modifier ou à créer.
; Cette procédure prend comme paramètre d'entrée le nom du fichier texte qu'elle stockera dans le champ "filename" de la structure "textfile_class.
; Elle alouera une zone mémoire de la taille de la structure "textfile_class" capable de recevoir du texte. (ce texte sera stocké dans "buffertext"
; champ de la structure "textfile_class".
; Chaque texte introduit dans cet objet est considéré comme une instance de celui-ci.
; C'est la raison pour laquelle "textfile_new" retourne un pointeur "*instance_textfile" permettant d'accéder aux membres de la structure "textfile_class".
; Pour que notre objet serve à quelque chose, il est essentiel que les outils qu'il renferme (autrement dit ses méthodes),
; puissent transformer le fichier texte qu'on aura introduit grâce à "textfile_new".
; Il faut donc que les méthodes de notre objet puissent aussi accéder à ce texte. 
; C'est pourquoi chaque méthode doit prendre comme premier paramètre d'entrée "*instance_textfile.textfile_class".
; De manière plus générale, le format "pe" ou "portable exécutable", propre aux fichiers exécutables, utilise un bloc mémoire pour chaque élément qu'il aura à stocker, lire ou modifier.
; celà explique les mots "global", "shared", ou "protected" que l'on trouve dans "purebasic".
; Notre objet n'échappe donc pas à cette règle.
; Chaque procédure / méthode et même chaque instance de celui-ci, est stocké dans des blocs de mémoires indépendants.
; C'est pourquoi nous devons créer une "interface physique" qui reprenne les méthodes décrites dans le bloc "interface ... endinterface",
; pour stocker l'adresse de ces méthodes après compilation.
; Cette interface physique est symbolisée par la structure "textfile_methodes".
; Cette structure se compose d'une série de pointeurs dans laquelle chaque pointeur reprend le nom de chaque entêtes de méthode décrites dans le bloc "interface ... endinterface".
; Par la suite, c'est le bloc "with ... endwith" qui associe chaque pointeur à l'adresse mémoire de la procédure leur correspondant.
; la variable "textfile_mthds" permet d'accéder à cette table.
; de même que la variable "*textfile_" permet au programme qui aura demandé l'instanciation de "textfile" d'accéder aux membres de chaque instance.
 
 #endofline = Chr(13) ; fin de ligne
#endofparagraph = Chr(13)+Chr(10) ; fin de paragraphe
objectname$ = "textfile" ; variable qui sera utilisée par les macros à la fin de ce fichier. 

; déclaration de la partie publique.
; le bloc suivant décrit la partie externe de notre boîte à texte,
; et présente les outils qu'elle contient.
Interface textfile
  loadtextfile ()
  countline ()
  Inserttext (nouvelle_chaine.s,ligne.l=-1,colonne.l=0)
  deleteline (ligne.l)
  savebuffertext ()
getwordline .l (word.s,start.l=1)  
EndInterface

; déclaration de la classe de l'objet
; Nous décrivons maintenant la partie interne de notre boîte à texte. 

Structure textfile_class
  *methodes ; pointeur indiquant à une instance de l'objet l'emplacement de ses méthodes.
  ; définition des membres de l'objet textfile.
  buffertext.s ; chaîne contenant le texte écrit dans le fichier *.txt
  filename.s ; chaîne contenant le chemin complet du fichier (unité:\dossier\nomfichier.extension)
EndStructure
Global *textfile_.textfile_class ; pointeur permettant au monde extérieur de modifier les propriétés d'une instance de textfile.
; création des méthodes (partie interne de l'objet).
Procedure .l loadtextfile (*instance_textfile.textfile_class)
  ; charge un fichier *.txt et stocke son contenu dans la variable (buffertext).
  ; paramètre d'entrée : 
  ; *instance_textfile : pointeur faisant référence à une instance de l'objet "textfile".
  ; Si vous appelez cette procédure en utilisant une instance de "textfile", ce pointeur ne doit pas être mentionné.
  ; par ailleurs, la procédure "new_textfile", doit être appelée avant l'utilisation de cette procédure. 
  ; en retour, la procédure renvoie le nombre de caractères copiés dans "buffertext".
  ; lecture des informations contenues dans le fichier *.txt
  numfile = ReadFile (#PB_Any,*instance_textfile\filename)
  If numfile > 0 ; le fichier a pu être ouvert on stocke son contenu dans buffertext
        While Not Eof(numfile)
          *instance_textfile\buffertext+ReadString (numfile)+#endofparagraph
        Wend
        CloseFile (numfile)
        ProcedureReturn Len(*instance_textfile\buffertext)
      Else ; erreur pendant le chargement ou la lecture du fichier
        CloseFile (numfile)
                ProcedureReturn 0
                EndIf ; fin de condition concernant le teste de numfile
              EndProcedure
              Procedure .l countline (*instance_textfile.textfile_class)
                ; retourne le nombre de lignes d'un fichier *.txt
                ; paramètre d'entrée : 
                ; - *instance_textfile : un pointeur faisant référence à une instance de textfile.
                ; celui-ci n'a pas besoin d'être précisé si vous utilisez une instance de cet objet.
                
                ProcedureReturn CountString (*instance_textfile\buffertext,Chr(13))+1
                EndProcedure
                
                Procedure Inserttext (*instance_textfile.textfile_class,nouvelle_chaine.s,ligne.l=-1,colonne.l=1)
                  ; insère du texte dans buffertext
                  ; paramètres d'entrée : 
                  ; - *instance_textfile : un pointeur faisant référence à une instance de l'objet textfile.
                  ; (lors de l'appel, ce pointeur n'a pas besoin d'être mentionné).
                  ; car il l'a déjà été lors de l'initialisation de la nouvelle instance de textfile.
                  ; (voir procédure "new").
                  ; de plus, lorsque pour appeler cette procédure on écrira : "nouvelleinstance\inserttext"
; nouvelleinstance est en réalité le pointeur (*instance_textfile")                  
                  ; - nouvelle_chaine : chaîne contenant le texte à insérer.
                  ; - ligne : contient le numéro de la ligne où doit s'effectuer l'insertion.
                  ; Si ce paramètre n'est pas préciser lors de l'appel, le texte sera inséré à la fin de buffertext.
                  ; - colonne : la colonne où doit s'effectuer l'insertion.
                  ; Si ce paramètre n'est pas précisé lors de l'appel, le texte est inséré au début de buffertext.
                  ; où au début de la ligne spécifiée dans la variable ligne.
                  Protected position_insertion.l ; contient la position où s'effectuera l'insertion.
                  Protected position_finligne_premiereligne.l ; position du premier retour chariot.
                  Protected position_finligne.l ; position d'une fin de ligne quelconque.
                  
                  Protected chaine.s ; chaîne provisoire.
                  
                  ; A. examen des paramètres
                  ; et calcul de la position où s'effectuera l'insertion.
                  
                  position_finligne_premiereligne = FindString(*instance_textfile\buffertext,Chr(13),1)
                  
                  If ligne=-1 Or colonne >= Len(*instance_textfile\buffertext)
                    ; on insère à la fin de buffertext
                    position_insertion = Len(*instance_textfile\buffertext)+1
                    
                  Else ; le développeur a précisé une ligne pour l'insertion
                    Select ligne
                      Case 0 ; ligne invalide, on insère la nouvelle chaîne au début de buffertext
                        position_insertion = 1
                      Case 1
                        ; inutile de parcourir toute la chaîne, l'insertion s'effectuera sur la première ligne.
                        ; toutefois, on s'assure que la colonne n'est pas supérieure au nombre de caractères présents sur la ligne.
                        If colonne >= position_finligne_premiereligne
                          position_insertion = position_finligne_premiereligne-1
                        Else ; chaîne insérée dans la ligne.
                          position_insertion = colonne
                        EndIf
                      Default
                        ; l'insertion s'effectuera dans une ligne quelconque de buffertext
                        ; Comme les chaînes de caractères sont constituées d'une suite de caractères stockés linéairements
                        ; et que la fin de ces chaînes n'est pas symbolisé par le retour à la ligne mais par le caractère chr(0),
                        ; il faut déterminer la position de la ligne précisée lors de l'appel de la procédure.
                        position_finligne = 1
                        
                        For i = 1 To ligne-1
                          position_insertion = FindString (*instance_textfile\buffertext,Chr(13),position_finligne)
                          position_finligne = position_insertion+1
                          
                        Next i
                        ; il faut maintenant s'assurer que la colonne ne soit pas plus grande que la longueur de la ligne où doit s'effectuer l'insertion.
                        ; si tel était le cas, nouvellechaine serait insérée à la mauvaise ligne.
                        If colonne <= position_finligne-1 ; ligne moin le retour chariot
                          position_insertion + colonne ; le texte sera inséré sur la bonne ligne
                        Else ; on ignore le paramètre colonne
                          ; et on insère le nouveau texte à la fin de la ligne.
                          position_insertion + (position_finligne-1)
                    EndIf ; fin de la condition liée au contrôle du paramètre colonne      
                    EndSelect ; fin des conditions liées au numéro de ligne
                  EndIf ; fin du calcul de la position d'insertion
                  *instance_textfile\buffertext = InsertString (*instance_textfile\buffertext,nouvelle_chaine,position_insertion)
                  
                EndProcedure
                
                Procedure deleteline (*instance_textfile.textfile_class,ligne.l)
                  ; efface une ligne
                  ; paramètre d'entrée : 
                  ; *instance_textfile : ce pointeur n'a pas besoin d'être précisé lors de l'appel,
                  ; car il s'agit du pointeur retourné par l'instance utilisée pour appeler cette procédure.
                  ; - ligne : nombre contenant le numéro de la ligne à supprimer.
                  chaine.s ; chaîne de caractères provisoire
                  ; chaque fin de ligne de texte d'un fichier *.txt est symbolisées par #endofline  ou  #endofparagraph.
                  ; Dans ces deux cas, on retrouve un #endofline !
 ; grâce à stringfield, on peut directement extraire la ligne à supprimer sans passer par des fonctions de listes.
                  chaine = StringField (*instance_textfile\buffertext,ligne,#endofline)
                  ; et on la supprime
                  *instance_textfile\buffertext = RemoveString (*instance_textfile\buffertext,chaine,ligne,ligne-1,2)
                  
                  EndProcedure
                  
                  Procedure .l savebuffertext (*instance_textfile.textfile_class)
                    ; sauvegarde sur un média physique le contenu de buffertext.
                    ; paramètre d'entrée : 
                    ; - *instance_textfile : pointeur faisant référence à l'instance de l'objet textfile.
                    ; Lors de l'appel, ce pointeur ne doit pas être mentionné, 
                    ; car il l'a déjà été lors de l'invocation de cette méthode.
                    ; en retour, la procédure renvoie "0" si une erreur est survenue,
                    ; si aucune erreur ne survient, la procédure renverra un nombre différent de 0.
                    ; (voir l'instruction "writestring").
                    Protected erreur.l ; code d'erreur
                    Protected numfile.l ; numéro du fichier ouvert par "creatfile".
                    
                    ; regarde si le champ "filename" de la structure textfile_class comporte un nom de fichier.
                    If Len(*instance_textfile\filename) = 0 ; aucun nom de fichier.
                      ; on invite le développeur ou l'utilisateur à indiquer l'emplacement physique de stockage du nouveau fichier.
                      *instance_textfile\filename = SaveFileRequester ("où voulez-vous enregistrer votre texte ?","c:\","fichiers textes (*.txt)|*.txt",0)
                    EndIf ; fin de condition liée à l'examen de "textfile_class\filename"
                    ; on sauvegarde le texte.
                    erreur = 0
                    numfile = CreateFile (#PB_Any,*instance_textfile\filename)
                    erreur = WriteString (numfile,*instance_textfile\buffertext)
                    CloseFile (numfile)
                    ProcedureReturn erreur
                  EndProcedure
                  
                  Procedure .l getwordline (*instance_textfile.textfile_class,word.s,startingline.l=1)
                    ; retourne le numéro de la ligne sur laquelle a eu lieu la première apparition du mot "word"
                    ; *instance_textfile : pointeur faisant référence à une instance de l'objet _textfile.
                    ; - word : le mot à rechercher.
                    ; startingline : le numéro de la ligne où doit commencer la recherche.
                    ; si ce paramètre n'est pas mentionné, la recherche commence au début du fichier.
                    ; en retour, la procédure renvoie un entier 32 bits, indiquant le numéro de la ligne, ou 0 si la recherche a été infructueuse.
                    
                    Protected position_depart.l=0
                    Protected derniere_ligne.l=0
                    
                    ; regardez la ligne suivante !
                    ; on appelle une méthode de notre objet textfile, 
                    ; ici, on précisera *instance_textfile car à ce stade, notre objet n'est pas initialisé.
                    derniere_ligne = countline (*instance_textfile)
                    finrecherche=#False
                    position_depart = startingline
                    ; boucle de recherche
                    For position_depart = startingline To derniere_ligne
                      ;a. on extrait une ligne du fichier :
                      ligne$ = LTrim (StringField (*instance_textfile\buffertext,position_depart,#endofline))
                      If CountString (ligne$,word) > 0 ; la ligne extraite contient l'expression contenue dans le paramètre d'entrée word.
                        finrecherche=#True ; indique que la recherche est finie
                        Break ; sort de la boucle de recherche
                        EndIf ; fin de condition countstring>0
                      Next position_depart ; fin de la boucle de recherche
                      ; la recherche a-t-elle été fructueuse ?
                      If finrecherche=#False ; non !
                        ; position_depart contient le numéro de la dernière ligne de texte du fichier, on remet cette variable à 0  
                        position_depart=0
                      EndIf ; fin de condition if finrecherche=#false
                      ProcedureReturn position_depart
                  EndProcedure
; maintenant que toutes les méthodes de notre objet ont été développées,
; on les références dans une table 
              Structure textfile_methodes
                *loadtextfile
                *countline
                *inserttext
                *deleteline
                *savebuffertext
                *getwordline
              EndStructure
              Global textfile_mthds.textfile_methodes
              ; initialisation de cette table
              With textfile_mthds
              \loadtextfile = @loadtextfile ()
                \countline = @countline ()
                \inserttext = @Inserttext ()
                \deleteline = @deleteline ()
                \savebuffertext = @savebuffertext()
                \getwordline = @getwordline ()
EndWith                
              ;constructeur de l'objet
              Procedure .l textfile_new (filename.s)
                ; initialise l'objet
                ; en entrée la procédure reçoit le nom du fichier text
                ; en retour, la procédure renvoie un pointeur faisant référence à la nouvelle instance de l'objet
                Shared textfile_mthds
                ; création d'une zone mémoire contenant l'objet textfile.
                
                *instance_textfile.textfile_class = AllocateMemory (SizeOf(textfile_class))
                   *instance_textfile\methodes = @textfile_mthds ; pointeur faisant référence à la table des méthodes de l'objet
                    *instance_textfile\filename = filename ; le nom du fichier *.txt de la nouvelle instance.
                    *textfile_ = *instance_textfile ; contient l'adresse de la nouvelle instance (utile pour pouvoir accéder aux membres de la nouvelle instance).)
                    
                ProcedureReturn *instance_textfile
              EndProcedure

Code : Tout sélectionner

; demotextfile.pb 
; démonstration pour instancier et utiliser l'objet textfile
XIncludeFile ("textfile.pbi") ; le module ci-dessus

Global texte.textfile
; texte est un pointeur référençant l'objet "textfile".
texte = textfile_new ("demo.txt")
; la méthode "textfile_new" de l'objet textfile est appelée, et initialise une zone mémoire pour notre instance "texte".
; le champ "filename" de la structure "textfile_class" prend la chaîne de caractères "demo.txt".
; Pour le moment, notre fichier "demo.txt" est vide, il n'est pas encore créé physiquement sur une unité de stockage,
; mais la zone "buffertext" de la structure "textfile_class" est prête à être remplie.
texte\Inserttext ("texte bidon !"+#endofparagraph)
; voici une première ligne de texte qui vient d'être ajoutée à buffertext.
              texte\inserttext ("juste pour tester"+#endofparagraph,2,2)
              texte\inserttext ("méthode insertext de l'objet textfile"+#endofparagraph,3,2)
              ; puis deux autres !
              ; En me relisant je me suis apperçu que j'avais oublié le mot "la" 
              ; nous l'insérons à notre texte.
              texte\inserttext ("la ",3,2)
              texte\inserttext ("Si vous avez des fins de paragraphes à faire, "+#endofparagraph,4,4)
              texte\inserttext ("n'oubliez pas d'insérer votre texte à partir de la deuxième colonne de chaque ligne, afin de garder le code retour chariot.",-1)
              ;
              
              ; on sauvegarde sur disque ce petit texte.
              erreur = texte\savebuffertext ()
              ; et on l'affiche.
              ; remarquez la variable "textfile_" qui permet d'accéder à un membre de l'objet "textfile"
              ; -membre qui se trouve dans la structure textfile_class-.
              
              Debug *textfile_\buffertext
              Debug "notre fichier de démonstration contient "+Str(texte\countline ())+" lignes de textes."
              ; les deux prochaines lignes, montrent l'utilisation de la méthode "getwordline"
              ; qui permet de retrouver le numéro de la ligne qui contient le texte spécifié dans le paramètre d'entrée "word".
              
              Debug "et le mot méthode se trouve sur la ligne n° "+Str(texte\getwordline ("méthode"))+"."
              Debug "la première apparition du mot ins se trouve à la ligne n° "+Str(texte\getwordline ("ins"))
              Debug "on peut également retrouver ce mot sur la ligne "+Str(texte\getwordline("insé",4))
              
              If erreur = 0
                Debug "l'enregistrement de ce petit texte a échoué"
              Else
                Debug "ce texte a été enregistré dans le dossier où se trouve le fichier textfile.pbi"
              EndIf
              End
 

Code : Tout sélectionner

; demo2.pb
; cette deuxième démonstration montre comment créer une collection de textes avec l'objet "textfile".
XIncludeFile ("textfile.pbi")
Dim mestextes.textfile(4) ; 4 textes seront chargés en mémoire
; les deux lignes suivantes vont recharger notre fichier demo.txt qui a été créé après l'exécution de notre première démonstration. 
mestextes(1) = textfile_new ("demo.txt")
mestextes(1)\loadtextfile ()
; on va maintenant créer une deuxième instance 
mestextes(2) = textfile_new ("text2.txt")
mestextes(2)\inserttext ("voici un deuxième texte de démonstration"+#endofparagraph,-1)
mestextes(2)\inserttext ("pour démontrer que notre objet supporte une collection"+#endofparagraph,2,2)
mestextes(3) = textfile_new ("texte3.txt")
mestextes(3)\inserttext ("Dans notre prochaine démonstration (demo3.pb), nous verrons comment l'on peut surcharger une méthode pour modifier son comportement"+#endofparagraph,3,2)
; Nous pourrions afficher ces trois textes.
; mais pour nous amuser un peu, nous allons les fusionner dans notre quatrième zone mémoire "buffertext(4)".

For i = 1 To 3
  *textfile_ = mestextes(i)
  texte$ + #endofparagraph+*textfile_\buffertext+#endofparagraph
Next i
mestextes(4) = textfile_new ("fusion.txt")
mestextes(4)\inserttext (texte$)
mestextes(4)\savebuffertext () ; "fusion.txt" vient d'être enregistré dans votre disque dur !
; la ligne suivante montre que l'on peu, grâce à l'accesseur "*textfile_" manipuler facilement un membre de notre objet.
*textfile_ = mestextes(4)
*textfile_\buffertext+#endofparagraph+"comme vous pouvez le constater, la fusion a bien été faite ! mais cette dernière ligne n'apparaîtra pas dans fusion.txt"
; nous allons maintenant renommer "fusion.txt" en "fusion2.txt"
*textfile_\filename = "fusion2.txt"
mestextes(4)\savebuffertext  (); ce fichier vient d'être créé physiquement.

Debug *textfile_\buffertext

End

Code : Tout sélectionner

freememory (texte(1))

Code : Tout sélectionner

 ;demo3.pb
; ici, nous allons modifier le comportement de la méthode "countline" de l'objet textfile.

XIncludeFile ("textfile.pbi")
Global textebidon.textfile
textebidon = textfile_new ("demo3.txt")
textebidon\inserttext ("voici une ligne de texte, pour montrer que la méthode countline de l'objet textfile fonctionne pour l'instant normalement",-1)
MessageRequester ("demo3.pb","le fichier demo3.txt qui n'est pour l'instant que virtuel, contient "+Str(textebidon \countline ())+" ligne de texte "+#endofparagraph+"je sais encore compter !!!",0)
; création de notre nouvelle méthode / routine
Procedure idontknow (*instance_textfile.textfile_class)
; insérer ici le nouveau code 
  ProcedureReturn @"Désolé mais la méthode countline n'habite plus à l'adresse indiquée !"
  EndProcedure
; comme le faisait les virus sous ms-dos avec la table des interruptions,
; nous allons transformer la table des méthodes de notre objet "textfile"
; pour que le pointeur *countline qui référence la méthode countline()
; prenne l'adresse de notre nouvelle procédure "Idontknow".

textfile_mthds\countline = @idontknow()
Debug PeekS (textebidon\countline ())
End
[code/]
Je ne m'atarderai pas sur cette dernière démonstration. J'espère en tout cas, Dayvid avoir répondu à ta question : "J'essaie de faire une fonction pour tout çà mais c'est pas encore au point".
Pour ceux qui auraient été séduit par cet objet ou "boîte à texte", je développe une série de macros qu'il faudra ajouter à la fin de "textfile.pbi". Ces macros permettront d'utiliser l'objet "textfile" comme une feuille de style. Cette feuille de style pourra être utilisée pour créer d'autres objets, dérivants de textfile.