Précalculation du nombre de fichier charger

[dayvid]

Salut !

Je suis coinser avec mon générateur de code Data

Je souhaite calculer le nombre de fichier charger grace à OpenFileRequester
mais je me heurte a un sérieux problème, J'ai essayer ceci qui ne marche pas :

Code : Tout sélectionner

; Veuillez charger plusieurs images...
NomFichier$ = OpenFileRequester("Choisissez quelques fichiers","","",0, #PB_Requester_MultiSelection)
SaveNomFichier$ = NomFichier$ ; Ici je sauvegarde la chaine de caractère mais étonnament il n'y a que le premier fichier qui apparais !

Debug SaveNomFichier$ ; C'est bien ce que je disais lol, il n'y a que le premier fichier qui apparais !

; Alors j'ai essayer ceci pour précalculer le nombre de fichier
While NomFichier$
  Debug NomFichier$
  NomFichier$ = NextSelectedFileName()
  NombreFichier + 1
Wend

Debug NombreFichier ; Ici ont connais le nombre de fichier charger grace a notre commande OpenFileRequester ! 

NomFichier$ = SaveNomFichier$ ; Ici je recharge ma chaine de caractère initiale me disans que ça va marcher a nouveau mais peine perdu lol

; Maintenant je fait mon job avec ceci
While NomFichier$
  Debug NomFichier$
  NomFichier$ = NextSelectedFileName()
Wend

; Mais plus rien ne fonctionne, pourquoi ?
; Seule le premier fichier est traité désormais !

Sans utiliser ceci car j'en est apsolument besoin apres !

Code : Tout sélectionner

While SelectionFichier$
  SelectionFichier$ = NextSelectedFileName()
  NombreFichier + 1
Wend

Merci d'éclarer ma lentèrne

[Torp]

Voilà une solution :

Code : Tout sélectionner

NewList FileName.s()

; Veuillez charger plusieurs images...
NomFichier$ = OpenFileRequester("Choisissez quelques fichiers","","",0, #PB_Requester_MultiSelection)
SaveNomFichier$ = NomFichier$ ; Ici je sauvegarde la chaine de caractère mais étonnament il n'y a que le premier fichier qui apparais !


While NomFichier$
AddElement(FileName())
FileName() = NomFichier$
NomFichier$ = NextSelectedFileName()	
Wend

Debug "Nombre de fichiers : " + Str(ListSize(FileName()))
Debug "---"
; Liste des fichiers
ForEach FileName()
	Debug FileName()
Next

Bye

[TazNormand]

NextSelectedFileName() "dépile" les noms de fichiers, il faut que tu passes par un tableau ou une liste chainée

Code : Tout sélectionner

; Veuillez charger plusieurs images...

NomFichier$ = OpenFileRequester("Choisissez quelques fichiers","","",0, #PB_Requester_MultiSelection)
SaveNomFichier$ = NomFichier$ ; Ici je sauvegarde la chaine de caractère mais étonnament il n'y a que le premier fichier qui apparais !

Debug SaveNomFichier$ ; C'est bien ce que je disais lol, il n'y a que le premier fichier qui apparais !

NewList listeFichiers.s()

While NomFichier$
	;Debug NomFichier$
	NombreFichier + 1
	AddElement(listeFichiers())
	listeFichiers()=NomFichier$	
	NomFichier$ = NextSelectedFileName()
Wend

Debug NombreFichier ; Ici on connait le nombre de fichier charger grace a notre commande OpenFileRequester ! 

ForEach listeFichiers()
  Debug listeFichiers()
Next

EDIT : Arf Grillé par Torp

REEDIT : Ton code a une erreur Torp, tu fais un NextSelectedFileName() trop tôt, du coup si tu sélectionnes 4 fichiers, ta liste chaînée n'en contient que 3

[Torp]

Voilà c'est corrigé

[dayvid]

Merci beaucoup, cependent ce n'est pas ça

Oui car voyez vous mes chers amis il faut IMPERATIVEMENT que je sache LE NOMBRE DE FICHIER AVENT D'UTILISER NextSelectedFileName()
En gros, une Procedure pour savoir le nombre de fichier et une autres pour le NextSelectedFileName()

Voilà en gros un bout de code pour que VOUS puissiez COMPRENDRE:

Code : Tout sélectionner

RepertoireUtilisateur$ = GetHomeDirectory()
  RepertoireUtilisateur$ + "\Bureau\"
  FichierParDefaut$ = RepertoireUtilisateur$
  Filtre$ = "Tous les fichiers (*.*)|*.*"
  Filtre  = 0
  NombreFichier = 0
  
  SelectionFichier$ = OpenFileRequester("Choisissez un ou plusieurs fichier à charger", FichierParDefaut$, Filtre$, Filtre, #PB_Requester_MultiSelection)
  SauvegardeSelectionFichier$ = SelectionFichier$
  
  ; Précalculation du nombre de fichier
  While SelectionFichier$
    SelectionFichier$ = NextSelectedFileName()
    NombreFichier + 1
  Wend
  
  Debug NombreFichier
  SetGadgetAttribute(#ProgressBarProgression, #PB_ProgressBar_Maximum, NombreFichier)
  
  SelectionFichier$ = SauvegardeSelectionFichier$
  NombreFichier = 0
  
  While SelectionFichier$
    NomFichier$ = GetFilePart(SelectionFichier$)
    CheminFichier$ = GetPathPart(SelectionFichier$)
    
    NombreFichier + 1
    
    NombreFichiersEditeur = CountGadgetItems(#ListIcon_explorateur_fichier)
    
    For VerifficationFichiers = 0 To NombreFichiersEditeur
      NomFichiers$ = GetGadgetItemText(#ListIcon_explorateur_fichier, VerifficationFichiers)
      
      If NomFichiers$ <> SelectionFichier$
        Trouver = 0
        Continue
      Else
        Trouver = 1
        DejaTrouver = 1
        Break
      EndIf
      
    Next
    
    If Trouver = 0
      AddGadgetItem(#ListIcon_explorateur_fichier, -1, CheminFichier$ + NomFichier$, GetAssociatedFileIcon(SelectionFichier$, #SHGFI_SMALLICON))
    EndIf
    
    SelectionFichier$ = NextSelectedFileName()
    
  Wend
  
  If DejaTrouver = 1
    MessageRequester("Information", "      Certains fichiers ont été igniorer parce-qu'ils sons déjà dans la liste !", 64)
  EndIf
  

Merci a vous

[TazNormand]

Avec le code de Torp ou le mien, tu peux connaître le nombre de fichiers présents dans la liste chaînée via la commande ListSize() :

EDIT : l'avantage de la liste chainée, c'est que tu peux retourner au premier fichier via ResetList(), la "vider" par FreeList(), etc...

Code : Tout sélectionner

; Veuillez charger plusieurs images...

NomFichier$ = OpenFileRequester("Choisissez quelques fichiers","","",0, #PB_Requester_MultiSelection)
SaveNomFichier$ = NomFichier$ ; Ici je sauvegarde la chaine de caractère mais étonnament il n'y a que le premier fichier qui apparais !


Debug SaveNomFichier$ ; C'est bien ce que je disais lol, il n'y a que le premier fichier qui apparais !

NewList listeFichiers.s()

While NomFichier$
	;Debug NomFichier$
	NombreFichier + 1
	AddElement(listeFichiers())
	listeFichiers()=NomFichier$	
	NomFichier$ = NextSelectedFileName()
Wend

Debug NombreFichier ; Ici on connait le nombre de fichier charger grace a notre commande OpenFileRequester ! 

ForEach listeFichiers()
  Debug listeFichiers()
Next
Debug "------"
Debug "Nb Fichier(s) sélectionné(s) : "+Str(ListSize(listeFichiers()))

[dayvid]

Bon c pas ça que je demande moi

Je ne veut pas que les deux truc soit dans la même boucle
je voudrait une boucle avec NombreFichier et une autre avec NextSelectedFileName()

Je veut savoir le nombre de fichier AVENT d'utiliser NextSelectedFileName() dans une boucle !

[brossden]

Je n'ai pas lu tous les posts mais je te propose celà :

Code : Tout sélectionner

NomFichier$ = OpenFileRequester("Choisissez quelques fichiers","","",0, #PB_Requester_MultiSelection)
RC.s = Chr(13)+Chr(10)
Txt.s=""

While NomFichier$
  Txt+NomFichier$+RC
  NomFichier$ = NextSelectedFileName()
  NombreFichier + 1
Wend

Txt + "Nombre Fichiers :" + Str(NombreFichier )
MessageRequester("liste des fichiers",Txt)

[TazNormand]

Bon, il semblerait qu'on ne puisse pas obtenir le nombre de fichiers sélectionnés par OpenFileRequester() et #PB_Requester_MultiSelection.

Donc à part adapter nos codes, t'as pas trop de choix.

Dans ton code, rien ne t'empêches de charger les fichiers sélectionnés par le requester dans la même procédure que le OpenFileRequester, et tu utilises la liste (en mode global) ailleurs.

[dayvid]

M'ouais c'est bien ce que je pensais

Vous croyez que ça pourais être une nouvelle fonctionnalité d'ajouter ça ?!

[Ar-S]

Le code de brossden marche très bien.
Mais comme l'a dit Taz, créer une liste ou un tableau reste de toute façon plus pratique pour les manipulations futures de ces fichiers ouverts.

[Backup]

Bon, il semblerait qu'on ne puisse pas obtenir le nombre de fichiers sélectionnés par OpenFileRequester()

la solution ( de Backupuser )
refaire le requester !!

les fichiers sont alors renvoyés séparé par le caractere "|" , il suffit de compter ce caractere a l'aide de countstring()+1
pour connaitre le nombre de fichier

code du openfileMultirequester()

Code : Tout sélectionner

; -----------------------------------------------------------------------------
; OpenMultiFileRequester ()
; -----------------------------------------------------------------------------

; A function to allow the calling of an OpenFileRequester that returns multiple
; files...

; WORK IN PROGRESS!!! Has a couple of bugs. See if you can tell why the alternative
; filter in the demo fails (at the bottom of this source), because I can't!

; [url]mailto:punkrockprogrammer@hi-toro.com">punkrockprogrammer@hi-toro.com

; -----------------------------------------------------------------------------
; NewLine ()
; -----------------------------------------------------------------------------

; Just returns a (Windows) newline/linefeed/whatever...

Procedure.s NewLine ()
  ProcedureReturn Chr (13) + Chr (10)
EndProcedure

; -----------------------------------------------------------------------------
; OpenMultiFileRequester ()
; -----------------------------------------------------------------------------

; Returns a string containing the path of the selected files, followed by the
; names of the selected files. NOTE that all are separated by a "|" character!

; Example of returned string:

; "C:\My Documents|Pixies - Debaser.mp3|Pixies - Mr Grieves.mp3"

; That means the selected files were in "C:\My Documents", and the filenames
; were "Pixies - Debaser.mp3" and "Pixies - Mr Grieves.mp3"

; PARAMETERS...

; window        -- the parent window. Use 0 if no window exists.
; title$        -- the text that appears in the requester's title bar ("Eg. Select files...").
; dir$          -- folder to start requester in (use "" for system default, usually "My Documents").
; filter$       -- a string defining a filter which says which files will be displayed (see below).
; maxfiles      -- the routine has to pre-allocate memory for the filenames; it reserves the
;                  maximum filename length (#MAX_PATH) allowed by Windows, multiplied by this value.
;                  If you pass zero, it'll reserve enough for 1024 maximum-length filenames...
; flags         -- the requester's flags. Use 0 for defaults, or -1 for literally no flags. You can
;                  specify your own flags as per the Win32 API docs if you know what you're doing!

; Returns "" (empty string) if it fails or user cancels...

Procedure.s OpenMultiFileRequester (window, title$, dir$, filter$, maxfiles, flags)

  DefType.OPENFILENAME req

  req\lStructSize        = SizeOf (OPENFILENAME)                ; Size of structure
  req\hWndOwner          = window                               ; Parent window
  req\hInstance          = #NULL                                ; Not needed

  If maxfiles = 0
    maxfiles = 1024                                             ; Default to 1024 * max filename length
  EndIf

  If flags = 0
    req\Flags = #OFN_ALLOWMULTISELECT | #OFN_EXPLORER | #OFN_HIDEREADONLY ; Default 'quick-fix' flags
  Else
    If flags = -1
      req\Flags = 0                                                       ; If you really want no flags, use -1!
    EndIf
  EndIf
 
  filter$ = filter$ + "||"                                      ; Filter string has to end with 2 x #NULL

  ; Poke filter string into a memory block (have to do this to keep Chr (0) in the string!)...
 
  If AllocateMemory (0, Len (filter$), 0)
    memstart = MemoryID ()
    For a = 0 To Len (filter$) - 1
      a$ = Mid (filter$, a + 1, 1)                              ; String chars are numbered 1... x, so adding 1 to a here...
      If a$ = "|"
        a$ = Chr (0)                                            ; Replace "|" with Chr (0)
      EndIf
      PokeB (memstart + a, Asc (a$))
    Next
  Else
    ProcedureReturn ""
  EndIf

  req\lpstrFilter        = MemoryID ()                          ; Filter is in our allocated memory
  req\lpstrCustomFilter  = #NULL                                ; Not needed
  req\nMaxCustFilter     = #NULL                                ; Not needed
  req\nFilterIndex       = 0                                    ; Use default filter order

  If AllocateMemory (1, (maxfiles * #MAX_PATH), 0) = #False
    ProcedureReturn ""
  EndIf
 
  req\lpstrFile          = MemoryID ()                          ; Buffer for file string
  req\nMaxFile           = (maxfiles * #MAX_PATH)               ; Buffer length
  req\lpstrFileTitle     = #NULL                                ; Not needed
  req\nMaxFileTitle      = #NULL                                ; Not needed
  req\lpstrInitialDir    = @dir$                                ; Initial directory
  req\lpstrTitle         = @title$                              ; Title of requester
 
  If GetOpenFileName_ (req)                                     ; OK, call the requester

    For a = 0 To req\nFileOffset - 1                           ; req\nFileOffset is first *file* in list
      file$ = file$ + Chr (PeekB (req\lpstrFile + a))           ; Before that is the selected directory...
    Next
   
    file$ = file$ + "|"

    byte = req\nFileOffset                                      ; OK, get rest of files after directory

    Repeat
      b$ = Chr (PeekB (req\lpstrFile + byte))                   ; Read the character
      If b$ = ""                                                ; If it's Chr (0), we check the next character
        If Chr (PeekB (req\lpstrFile + byte + 1)) = ""          ; If the next character is also Chr (0), we're done
          gotall = #True
        Else
          file$ = file$ + "|"                                   ; Nope, just one Chr (0), so we have a complete filename
        EndIf
      Else
        file$ = file$ + b$                                      ; Not Chr (0), so we add it to the filename
      EndIf
      byte = byte + 1                                           ; Next byte in string...
    Until gotall = #True Or byte = (maxfiles * #MAX_PATH) - 1

    ; Free our memory, because this might get called over and over again...

    FreeMemory (0)
    FreeMemory (1)

    ProcedureReturn file$                                     ; We're done!
  Else
    ProcedureReturn ""                                        ; User cancelled requester
  EndIf
   
EndProcedure

; -----------------------------------------------------------------------------
; Demo
; -----------------------------------------------------------------------------

; NOTE that this demo just replaces the "|" characters in the returned string with
; newlines, so each filename gets a separate line in the requester :)

filter$ = "Text files|*.txt|Zip files|*.zip|All files|*.*"   ; Weird -- Zips don't get shown this way round,
                                                              ; plus it opens in source folder instead of default... :/

;filter$ = "Zip files|*.zip|Text files|*.txt|All files|*.*"    ; This one works

getfile$ = OpenMultiFileRequester (0, "Select files to open...", "", filter$, 0, 0)

result$ = ReplaceString (getfile$, "|", NewLine ())

If result$
  MessageRequester ("Path: " + path$, "Selected files..." + NewLine () + NewLine () + result$, 0)
EndIf

[TazNormand]

@Dobro : il serait quand même plus pratique que si il y a multi-sélection, NomFichier$ devienne un tableau de chaine.

voire en "pseudo-code" :

Code : Tout sélectionner

$fichier$=new Array();
$fichier$=OpenFileRequester(...);
select sizeOf($fichier){
  case 0;
    Debug "aucun fichier sélectionné";
    break;

  case 1
    Debug "Un seul fichier";
    break;

  case else
    Debug "Plusieurs fichiers sélectionnés (".sizeOf($fichier)." en tout)
    break;
}

Fread, si jamais tu passes par là, à implémenter dans PB 4.62

[dayvid]

Dobro, ton code ne marche pas

Ligne 54

Code : Tout sélectionner

DefType.OPENFILENAME req

[Backup]

@Dobro : il serait quand même plus pratique que si il y a multi-sélection, NomFichier$ devienne un tableau de chaine.

une chaine du type NomFichier$= "toto|titi|tutu|riri|fifi|loulou"
est deja un tableau de chaine !

puisqu'avec :

Code : Tout sélectionner

NomFichier$= "toto|titi|tutu|riri|fifi|loulou"
for i=1 to countstring(NomFichier$,"|")+1
	debug stringfield(NomFichier$,i,"|")
next i

tu peux ressortir tout les membres du "tableau" NomFichier$

et qu'un simple appel genre

Code : Tout sélectionner

debug stringfield(NomFichier$,3,"|") ; ressort tutu le 3em element de notre tableau :o)

peut permettre de lire le membre qu'on veux dans ce "tableau"


un tableau DIM c'est exactement la meme chose !

sauf que la notre espace mémoire est lineaire dans la chaine , les "" representant le debut et la fin du tableau

un simple NomFichier$+" " permet de redimensionner notre "tableau"
ou un simple NomFichier$="" permet de l'effacer


les chaines c'est vraiment puissant, si on ose les regarder en face

n'oublions pas qu'en etant programmeur nous n'avons a faire en fait qu'a des espaces mémoire rien de plus