PureBasic Forums - English

Code: Select all

; By Dobro
Declare cut_file(NomFichier$,taille_bloc) ; taille a définir en kilo octet
Declare glue_file(NomFichier$,style) ;

#file=0
#file2=1




; ; **************** Decoupe *****************************************************
MessageRequester("couper" ,"Cut open a file")
NomFichier$ = OpenFileRequester("ouvrir", "c:\", "", 0)
taille_bloc=50 ; 50 kilo_octet le bloc
cut_file(NomFichier$,taille_bloc) ; size was set in kilobyte   ; ici on decoupe le fichier en morceau
MessageRequester("info" ,"here is done ... Check your folder ... do not leave the prg")

; ; ******************************************************************************************

MessageRequester("recoller","open a file pick"+chr(10)+"choose the first file cut (**** ^1 )")
; ************* on recolle ******************************
NomFichier$ = OpenFileRequester("ouvrir", "c:\", "", 0)
style=1 ; delete files block as a measure of treatment
;style=0 ;  lets block the files, do not erased
glue_file(NomFichier$,style) ;
; ****************************************************
MessageRequester("info" ,"here is done ... reglued file, check in your file ... you can leave the prg")



Procedure cut_file(NomFichier$,taille_bloc) ; taille a définir en kilo octet   
   ; By Dobro
   Protected File,TailleFichier.q,morceau.q,length.q,flag
   Protected  part,pointeur
   File = OpenFile(#file,NomFichier$)
   TailleFichier.q=FileSize(NomFichier$)
   If ReadFile(#file, NomFichier$)
      length.q = Lof(#file)                       ; Lit la taille en octets du fichier
      ;******************* Taille d'un bloc  ***********************
      morceau.q= taille_bloc*1024   ; n=l'endroit de la coupe , ici les blocs (partie de fichier) feront  50 Kilo octets 
      ; *****************************************************************************
      If morceau>length ; on verifie que notre taill_bloc ne soit pas plus grand que le fichier
         morceau=length ; si c'est le cas , on le met a la meme taille que le fichier (il n'y aura qu'un seul fichier generé)
      EndIf 
      ; *************** Au boulot   la decoupe ******************************
      debut :
      *Buffer = AllocateMemory(morceau) ; on alloue un tampon memoire
      FileSeek(#file,pointeur)  ; on place le pointeur d'ecriture au bon endroit dans le fichier
      ReadData(#file, *Buffer, morceau)  ; on lis le premier bloc de donnée du fichier source
      If length <morceau  ; on regarde si la longueur du fichier qui reste a traiter est plus petite que notre taille de bloc
         morceau=length ; si c'est le cas , on traite seulement la partie qui reste a traiter
         flag=1 ; ceci empechera la boucle de recommencer une ecriture d'un autre Bloc
      EndIf 
      part=part+1 ; ceci participe a l'ecriture du numero 'increment dans le nom du fichier
      ; **************on sauve le bloc en cours ******************************
      OpenFile(#file2,NomFichier$+"^"+Str(part))
      WriteData(#file2, *Buffer, morceau)
      CloseFile(#file2) 
      If Eof(#file)=0
         pointeur=pointeur+morceau
         If flag=0 ; apparement on a pas fini de traiter le fichier source
            length=length-morceau ; on retire de la taille restante a traiter , la taille du bloc en cours
            FreeMemory(*Buffer); on libere la memoire
            Goto debut  ; et on y retourne pour traiter la suite
            Else
            FreeMemory(*Buffer); on a fini , on libere la memoire
         EndIf
      EndIf 
      CloseFile(#file)  ; on concretise l'ecriture de notre fichier Cible et reconstintué
      ; si l'on arrive la, c'est qu'on a fini d'ecrire tout les blocs :D
      ; ******************************************************************** 
   EndIf
EndProcedure


Procedure glue_file(NomFichier_part$,style) ;
   ; by Dobro
   Protected verif,numero,TailleFichier_part.q,flag2,TailleFichier_cible.q,nom_fichier_cible$, a$,b$
   ; si style=0 on laisse les fichiers bloc
   ; si style=1 on efface les fichiers part au fur a mesure
   ; *************** Au boulot   on recolle ******************************   
   Cont:
   verif=verif+1
   file = OpenFile(#file,NomFichier_part$) ; on ouvre le fichier en cours
   numero= Val( StringField(NomFichier_part$, 2, "^")) ; on recupere le numero du fichier en cours
   TailleFichier_part.q=FileSize(NomFichier_part$)  ; on recupre la taille du fichier en cours
   *Buffer = AllocateMemory(TailleFichier_part.q) ; on alloue un buffer memoire
   ReadData(#file, *Buffer, TailleFichier_part.q)  ; on lis la totalité du fichier en cours
   If flag2=0 ;on fait ça qu'une fois
      nom_fichier_cible$=StringField(NomFichier_part$, 1, "^") ; on recupere le path+le nom du fichier en cours 
      TailleFichier_cible.q=FileSize(nom_fichier_cible$) 
   EndIf
   
   If verif=1 ; on fait ça qu'une fois
      If TailleFichier_cible.q>0 ; le fichier de destination existe deja... soit on met une alerte ici
         TailleFichier_cible.q=0
         ; soit on efface le fichier qui existe deja !!
         ; ********* pour effacer le fichier deja existant ************
         ; DeleteFile(NomFichier$) ;
         ; ******************************************************
         ; MessageRequester("Attention", "Le fichier que vous voulez reconstituer est deja present",#PB_MessageRequester_Ok )
         ; ProcedureReturn -1 ; on quitte la procedure sans rien faire :D
         a$=StringField(nom_fichier_cible$, 1,".")
         b$=StringField(nom_fichier_cible$, 2,".")
         nom_fichier_cible$=a$+"_"+Str(Random(255))+"."+b$ ; on redefini un nouveau fichier cible pour pas toucher a l'original
         flag2=1
      EndIf
   EndIf
   
   Resultat = OpenFile(#file2, nom_fichier_cible$) ; on ouvre le fichier de destination
   FileSeek( #file2,Lof(#file2) ) ; va a la fin du fichier  de destination en cours d'ecriture (on deplace le pointeur d'ecriture)
   WriteData(#file2, *Buffer, TailleFichier_part.q)  ; on vide le tampon dedans
   CloseFile(#file2) ; finalise et concretise l'ecriture du fichier
   If style=1 ; si l'on a decider d'effacer les fichier Blocs 
      CloseFile(#file)  ; faut fermer le fichier pour pouvoir l'effacer
      DeleteFile(NomFichier_part$) ; ben on les effaces un par un, apres avoir ete traité
      Else
      CloseFile(#file)  ; ferme le fichier on passe au suivant
   EndIf
   If  FileSize(StringField(NomFichier_part$, 1,"^")+"^"+Str(numero+1)) >0 ; teste si le fichier bloc suivant existe
      NomFichier_part$=StringField(NomFichier_part$, 1,"^")+"^"+Str(numero+1) ; on se met a jour pour traiter le futur fichier suivant puisqu'il existe
      FreeMemory(*Buffer) ; on libere notre tampon, puisqu'on va le recreer !! :D
      Goto Cont
      Else
      FreeMemory(*Buffer)  ; on libere notre tampon , puisqu'on a fini
   EndIf
   
   ; ********************************************************************
EndProcedure

; EPB