public void LoadMyFileSystemPlus(MyFileSystemPlus mfsp)
{
currentFileSystem = mfsp;
if(currentFileSystem!=null)
LoadNode(currentFileSystem.Root);
else
LoadNode(null);
}
public bool BeginIncorporaMetadata(FileSystemNodePlus<MyAddittionalData> nodo, MyFileSystemPlus mfsp)
{
if(GetIncorporaMetadataStatus()==MetadataIncluderAsyncStatus.nul)
{
Worker = new Thread(() =>
{
IncorporaMetadataRicorsivo(nodo, mfsp);
OnEnd?.Invoke();
});
Worker.Start();
return true;
}
else
{
return false;
}
}
private void IncorporaMetadataRicorsivo(FileSystemNodePlus<MyAddittionalData> nodo, MyFileSystemPlus mfsp)
{
foreach (FileSystemNodePlus<MyAddittionalData> n in nodo.GetAllNode())
{
while (_Pause)
Thread.Sleep(100);
if (n.Type == FileSystemNodePlusType.Directory)
IncorporaMetadataRicorsivo(n, mfsp);
else if (n.Type == FileSystemNodePlusType.File)
{
IncorporaMetadataNodo(n, mfsp.GetFullPath(n));
}
}
}
public CountParameter(MyFileSystemPlus mfsp, FFmpegMetadata EndFormat)
{
this.mfsp = mfsp;
this.EndFormat = EndFormat;
}
/// <summary>
/// DEPRECATA! NON FUNZIONANTE
/// </summary>
/// <param name="nodo"></param>
/// <param name="mfsp"></param>
/// <param name="EndFormat"></param>
/// <returns></returns>
private long CalcoloSpazio(FileSystemNodePlus<MyAddittionalData> nodo, MyFileSystemPlus mfsp, FFMpegMediaMetadata EndFormat)
{
if (EndFormat is FFMpegMediaMetadataMp3 )
{
long t = 0;
foreach (FileSystemNodePlus<MyAddittionalData> n in nodo.GetAllNode())
{
while (Pause)
Thread.Sleep(100);
if (n.Type == FileSystemNodePlusType.Directory)
t += CalcoloSpazio(n, mfsp, EndFormat);
else if (n.Type == FileSystemNodePlusType.File)
{
String p = mfsp.GetFullPath(n);
if (SystemService.FileExist(p))
{
textBox_source.SetTextInvoke(p);
if(FFmpeg.GetMetadata(p).MediaMetadata!=null)
{
String temp = FFmpeg.GetMetadata(p).MediaMetadata.Duration;
string[] st = temp.Split(':');
long tt = 0;
if (st.Length == 3)
{
try
{
tt = st[0].ParseInt() * 144000; //trovo i secondi e moltiplico x 320/8 -> 3600*40
tt += st[1].ParseInt() * 2400; //trovo i secondi e moltiplico x 320/8 -> 60*40
tt += st[2].Split('.')[0].ParseInt() * 40; //trovo i secondi e moltiplico x 320/8 -> 60*40
}
catch (Exception e) { }
t += tt;
}
}
}
progressBar_total.SetValueInvoke(progressBar_total.Value + 1);
}
}
return t;
}
return 0;
}
/// <summary>
/// Scorre tutte le cartelle presenti nella cartella Reale e controlla i file:
/// se un file viente trovato nella cartella e nel FileSystem allora viene impostato il flag Selezionato a true
/// se un file non viene trovato nel FileSystem, viene aggiunto al FileSystem Temp
///
/// </summary>
/// <param name="FileSystem"></param>
/// <param name="CurrentPath">Path da controllare</param>
/// <param name="Temp"></param>
private void UpdateRecursiveRealToList(MyFileSystemPlus FileSystem, String CurrentPath, FileSystemNodePlus<MyAddittionalData> Temp)
{
//scorro tutte le cartelle
//imposto selezionato a tutti i file che trovo
//alla fine rimuovo i file non selezionati
String[] tfolder = SystemService.GetDirectories(CurrentPath);
foreach (String s in tfolder)
{
UpdateRecursiveRealToList(FileSystem, s, Temp.CreateNode(s.TrimEnd('\\', '/').SplitAndGetLast("\\", "/"), FileSystemNodePlusType.Directory));
}
String[] tfile = SystemService.GetFiles(CurrentPath);
foreach (String s in tfile)
{
if (LoadOption == null || (LoadOption != null && (!LoadOption.RestrictExtensionEnable || LoadOption.RestrictExtension.Contains(System.IO.Path.GetExtension(s).TrimStart('.').ToLower()))))
{
FileSystemNodePlus<MyAddittionalData> n = FileSystem.GetNodeFromPath(s);
if (n == null)
{
//se il file non viene trovato vuol dire che è nuovo e lo aggiungo al temp
Temp.CreateNode(s.TrimEnd('\\', '/').SplitAndGetLast("\\", "/"), FileSystemNodePlusType.File);
}
else if (n.AddittionalData.Size == SystemService.FileSize(s) && n.AddittionalData.MD5!=null && n.Type == (SystemService.FileExist(s)?FileSystemNodePlusType.File:FileSystemNodePlusType.Directory))
{
// il file non è stato modificato ( dimensine )
// ha l'md5
// che il tipo corrisponda ( per errori di vecchi Index
// lo seleziono ( vuol dire che lo tengo ) .
n.AddittionalData.Selezionato = true;
}
else // nel caso in cui il file è stato modificato
{
//reinserisco il file all'interno di temp in modo che venga rianalizzato
Temp.CreateNode(s.TrimEnd('\\', '/').SplitAndGetLast("\\", "/"), FileSystemNodePlusType.File);
}
}
}
}
private void S_OnSingleFileMouseUp(SingleFile SF)
{
if (Type == FileBrowserType.Playlist)
{
Cursor.Current = Cursors.Default;
if (DownNode != SF.Nodo)
{
if (SF.Nodo.Type == FileSystemNodePlusType.Directory)
{
String path = CurrentNode.GetFullPath();
MyFileSystemPlus Clo = currentFileSystem.Clone();
FileSystemNodePlus<MyAddittionalData> nn = Clo.GetNodeFromPath(path);
MyFileSystemPlus temp = new MyFileSystemPlus();
temp.Root = nn;
temp = temp.FindPreserveTree((x) => { return x.AddittionalData.Selezionato; }, FileSystemNodePlusControlType.Pre);
CurrentNode.Remove((t) => { return t.Type == FileSystemNodePlusType.File && t.AddittionalData.Selezionato; }, FileSystemNodePlusLevelType.AllNode, FileSystemNodePlusControlType.Pre);
CurrentNode.Remove((t) => { return t.Type == FileSystemNodePlusType.Directory && t.ChildCount == 0 && t.AddittionalData.Selezionato; }, FileSystemNodePlusLevelType.AllNode, FileSystemNodePlusControlType.Post);
temp.DeselectAll();
SF.Nodo.Merge(temp.Root);
SF.Selected = false;
ReloadNode();
if (PlaylistChanged != null)
PlaylistChanged(currentFileSystem);
}
}
DownNode = null;
}
}
/// <summary>
/// Controlla l'IndexFile corrente con la Path memorizzata nell'IndexFile; rimuove i file non trovati ed aggiunge i nuovi file.
/// </summary>
public void Update()
{
if (GUI)
StartGui();
if (CanUseGui)
IFForm.SetMessage("Lettura media...");
if (RootFileSystem == null)
return;
//controllo se esistono, su disco, tutti i file presenti nel mio FileSystem
// quelli che non esistono li cancello
// mentre sono in una cartella controllo anche se ci sono nuovi file da aggiungere
MyFileSystemPlus t = new MyFileSystemPlus();
t.RootPath = RootFileSystem.RootPath;
t.Root = new FileSystemNodePlus<MyAddittionalData>(RootFileSystem.RootPath.TrimEnd('\\', '/').SplitAndGetLast("\\", "/"), FileSystemNodePlusType.Directory);
// incorporo i metadati in t
RootFileSystem.DeselectAll();
UpdateRecursiveRealToList(RootFileSystem, RootFileSystem.RootPath, t.Root);
RootFileSystem.Root.SetParentOnAllChild(FileSystemNodePlusLevelType.AllNode);
if (CanUseGui)
IFForm.AddRimossi(RootFileSystem.FindAll((x)=> { return x.Type == FileSystemNodePlusType.File && !x.AddittionalData.Selezionato; }).Select((x)=> { return x.GetFullPath(); }).ToArray());
if (CanUseGui)
IFForm.SetMessage("Rimozione file non trovati...");
//cancello tutti i file non trovati o modificati ( i modificati sono anche stati aggiunti a t )
RootFileSystem.RimuoviFileNonSelezionati();
RootFileSystem.RimuoviCartelleVuote();
RootFileSystem.DeselectAll();
if (CanUseGui)
IFForm.SetMessage("Inclusione Metadata...");
_IncorporaMetadata(t);
if (CanUseGui)
IFForm.SetMessage("Merge dei nuovi dati...");
RootFileSystem.Merge(t);
if (CanUseGui)
IFForm.SetMessage("Finalizzazione Index File");
RootFileSystem.Root.SetParentOnAllChild(FileSystemNodePlusLevelType.AllNode);
if (CanUseGui)
IFForm.SetMessage("Fine!");
if (CanUseGui)
WaitGUIClose();
}
/// <summary>
/// Controlla l'indice corrente con la Path specificata; rimuove i file non trovati ed aggiunge i nuovi file.
/// </summary>
/// <param name="RootPath">Path della cartella su cui eseguire il controllo </param>
public void Update(String RootPath)
{
if (RootFileSystem == null)
RootFileSystem = new MyFileSystemPlus();
RootFileSystem.RootPath = RootPath;
Update();
}
private void _IncorporaMetadata(MyFileSystemPlus t)
{
MetadataIncluderServices MI = new MetadataIncluderServices();
MI.OnNodeStartProcessing += OnNodeStartProcessing;
MI.OnNodeProcessed += OnProcessedMetadata;
MI.OnProgressChangedSingleMD5 += (double percent) =>
{
OnPercentChangeMetadata?.Invoke(percent);
};
MI.OnEnd += OnEndMetadata;
if (CanUseGui)
{
IFForm.FormClosed += (object sender, System.Windows.Forms.FormClosedEventArgs e) =>
{
MI.AbortIncorporaMetadata();
};
int Total = t.Root.GetNodeCount(FileSystemNodePlusLevelType.AllNode, FileSystemNodePlusType.File);
IFForm.SetProgressTotalMax(Total);
double buffer = 0;
MI.OnNodeStartProcessing += (FileSystemNodePlus<MyAddittionalData> nodo, string PathNodo) =>
{
buffer = 0;
if (CanUseGui)
IFForm.SetSource(PathNodo);
};
MI.OnNodeProcessed += (FileSystemNodePlus<MyAddittionalData> nodo, string PathNodo, MetadataIncluderError Err) =>
{
buffer = 100;
if (CanUseGui)
{
IFForm.SetProgressSingleValue((int)buffer);
IFForm.SetProgressTotalValue(IFForm.GetProgressTotalValue() + 1);
if (Err == MetadataIncluderError.nul)
{
IFForm.AddAggiunti(nodo.GetFullPath());
}
else if (Err == MetadataIncluderError.MD5Err)
{
IFForm.AddProblemi("MD5 error - " + nodo.GetFullPath());
}
else if (Err == MetadataIncluderError.FileNonTrovato)
{
IFForm.AddProblemi("Not Found - " + nodo.GetFullPath());
}
else
{
throw new Exception("Errore non implementato");
}
}
};
MI.OnEnd += () =>
{
IFForm.SetProgressTotalValue(IFForm.GetProgressTotalValue() + 1);
IFForm.Fine();
};
MI.OnProgressChangedSingleMD5 += (double AddPercent) =>
{
buffer += AddPercent;
if (CanUseGui)
IFForm.SetProgressSingleValue((int)buffer);
};
}
MI.IncorporaMetadata(t.Root, t);
t.Root.Remove((x) => { return x.Type == FileSystemNodePlusType.File && (x.AddittionalData.MD5 == "" || x.AddittionalData.MD5 == null); }, FileSystemNodePlusLevelType.AllNode, FileSystemNodePlusControlType.Post);
}
private void _CreateIndexFile(String Path, FileSystemPlusLoadOption lo)
{
if (GUI)
StartGui();
if (CanUseGui)
IFForm.SetMessage("Lettura media...");
MyFileSystemPlus t = new MyFileSystemPlus(Path, lo);
if (CanUseGui)
IFForm.SetMessage("Inclusione Metadata...");
_IncorporaMetadata(t);
if (CanUseGui)
IFForm.SetMessage("Finalizzazione Index File");
RootFileSystem = t;
RootFileSystem.Root.SetParentOnAllChild(FileSystemNodePlusLevelType.AllNode);
Completed = true;
if (CanUseGui)
IFForm.SetMessage("Fine!");
}
public IndexFile(MyFileSystemPlus ListElement, bool GUI = true)
{
this.RootFileSystem = ListElement;
this.GUI = GUI;
}
public IndexFile(bool GUI=true)
{
this.RootFileSystem = null;
this.GUI = GUI;
}
public IndexFile()
{
this.RootFileSystem = null;
this.GUI = true;
}
void LoadPlaylist(Playlist p)
{
Current = p.FileSystem;
fileBrowser1.Type = GUI.Controls.FileBrowserType.Playlist;
ReloadCurrentFileSystem();
}
void LoadIndexMediaLibrary()
{
Current = IndexMediaLibrary.RootFileSystem;
status = MainFormStatus.RootBrowsing;
ReloadCurrentFileSystem();
}
