/// <summary>
/// Filtrer les fichiers SW
/// </summary>
/// <param name="TypeDesFichiersFiltres"></param>
public void FiltreSW(TypeFichier_e TypeDesFichiersFiltres, Boolean FiltreDistinct = true)
{
String TxtFiltre;
List <String> Filtre = new List <string>();
if (FiltreDistinct)
{
foreach (TypeFichier_e T in Enum.GetValues(typeof(TypeFichier_e)))
{
if (TypeDesFichiersFiltres.HasFlag(T))
{
Filtre.Add(CONSTANTES.InfoFichier(T, InfoFichier_e.cNom) + " (*" + CONSTANTES.InfoFichier(T) + "|*" + CONSTANTES.InfoFichier(T));
}
}
TxtFiltre = String.Join("|", Filtre);
}
else
{
foreach (TypeFichier_e T in Enum.GetValues(typeof(TypeFichier_e)))
{
if (TypeDesFichiersFiltres.HasFlag(T))
{
Filtre.Add("*" + CONSTANTES.InfoFichier(T));
}
}
TxtFiltre = "Fichier SolidWorks (" + String.Join(", ", Filtre) + ")" + "|" + String.Join("; ", Filtre);
}
_Dialogue.Filter = TxtFiltre;
}
/// <summary>
/// Retourne la liste des fichiers du dossier sélectionné
/// </summary>
/// <param name="TypeDesFichiers"></param>
/// <param name="NomARechercher"></param>
/// <param name="ParcourirLesSousDossier"></param>
/// <returns></returns>
public ArrayList SelectionnerUnDossierEtRenvoyerFichierSW(TypeFichier_e TypeDesFichiers, String NomARechercher = "*", Boolean ParcourirLesSousDossier = false)
{
ArrayList pArrayFichiers = new ArrayList();
String CheminDossier = SelectionnerUnDossier();
SearchOption Options = SearchOption.TopDirectoryOnly;
if (ParcourirLesSousDossier)
{
Options = SearchOption.AllDirectories;
}
if (Directory.Exists(CheminDossier))
{
foreach (String CheminFichier in Directory.EnumerateFiles(CheminDossier, NomARechercher, Options))
{
eFichierSW pFichierSW = new eFichierSW();
if (pFichierSW.Init(_SW))
{
pFichierSW.Chemin = CheminFichier;
if ((pFichierSW.TypeDuFichier & TypeDesFichiers) != 0)
{
pArrayFichiers.Add(pFichierSW);
}
}
}
}
return(pArrayFichiers);
}
/// <summary>
/// Filtrer les fichiers SW
/// </summary>
/// <param name="TypeDesFichiersFiltres"></param>
public void FiltreSW(TypeFichier_e TypeDesFichiersFiltres, Boolean FiltreDistinct = true)
{
Log.Methode(cNOMCLASSE);
String TxtFiltre;
List<String> Filtre = new List<string>();
if (FiltreDistinct)
{
foreach (TypeFichier_e T in Enum.GetValues(typeof(TypeFichier_e)))
{
if (TypeDesFichiersFiltres.HasFlag(T))
Filtre.Add(CONSTANTES.InfoFichier(T, InfoFichier_e.cNom) + " (*" + CONSTANTES.InfoFichier(T) + "|*" + CONSTANTES.InfoFichier(T));
}
TxtFiltre = String.Join("|", Filtre);
}
else
{
foreach (TypeFichier_e T in Enum.GetValues(typeof(TypeFichier_e)))
{
if (TypeDesFichiersFiltres.HasFlag(T))
Filtre.Add("*" + CONSTANTES.InfoFichier(T));
}
TxtFiltre = "Fichier SolidWorks (" + String.Join(", ", Filtre) + ")" + "|" + String.Join("; ", Filtre);
}
_Dialogue.Filter = TxtFiltre;
}
/// <summary>
/// Retourne la liste des fichiers du dossier sélectionné
/// </summary>
/// <param name="TypeDesFichiers"></param>
/// <param name="NomARechercher"></param>
/// <param name="ParcourirLesSousDossier"></param>
/// <returns></returns>
public ArrayList SelectionnerUnDossierEtRenvoyerFichierSW(TypeFichier_e TypeDesFichiers, String NomARechercher = "*", Boolean ParcourirLesSousDossier = false)
{
ArrayList pArrayFichiers = new ArrayList();
String CheminDossier = SelectionnerUnDossier();
SearchOption Options = SearchOption.TopDirectoryOnly;
if (ParcourirLesSousDossier)
Options = SearchOption.AllDirectories;
if (Directory.Exists(CheminDossier))
{
foreach (String CheminFichier in Directory.EnumerateFiles(CheminDossier, NomARechercher, Options))
{
eFichierSW pFichierSW = new eFichierSW();
if (pFichierSW.Init(_SW))
{
pFichierSW.Chemin = CheminFichier;
if (TypeDesFichiers.HasFlag(pFichierSW.TypeDuFichier))
pArrayFichiers.Add(pFichierSW);
}
}
}
return pArrayFichiers;
}
internal static String InfoFichier(TypeFichier_e TypeFichier, InfoFichier_e Info = InfoFichier_e.cExt)
{
String pDocExt = "";
String pGabaritExt = "";
String pNom = "";
switch (TypeFichier)
{
case TypeFichier_e.cAssemblage:
pDocExt = ".SLDASM";
pGabaritExt = ".ASMDOT";
pNom = "Assemblage";
break;
case TypeFichier_e.cPiece:
pDocExt = ".SLDPRT";
pGabaritExt = ".PRTDOT";
pNom = "Pièce";
break;
case TypeFichier_e.cLibrairie:
pDocExt = ".SLDLFP";
pGabaritExt = ".PRTDOT";
pNom = "Librairie";
break;
case TypeFichier_e.cDessin:
pDocExt = ".SLDDRW";
pGabaritExt = ".DRWDOT";
pNom = "Mise en plan";
break;
}
switch (Info)
{
case InfoFichier_e.cExt:
return pDocExt;
case InfoFichier_e.cGabarit:
return pGabaritExt;
case InfoFichier_e.cNom:
return pNom;
}
return "";
}
public String Extension(TypeFichier_e TypeFichier)
{
return CONSTANTES.InfoFichier(TypeFichier);
}
/// <summary>
/// Fonction interne, renvoi la liste des composants sélectionnés.
/// </summary>
/// <param name="NomComposant"></param>
/// <param name="Marque"></param>
/// <returns></returns>
public ArrayList ListeDesComposantsSelectionnes(TypeFichier_e TypeDeFichier, String NomComposant = "", int Marque = -1)
{
Log.Methode(cNOMCLASSE);
// Liste à renvoyer
ArrayList pListeComposants = new ArrayList();
for (int i = 1; i <= _SwGestDeSelection.GetSelectedObjectCount2(Marque); i++)
{
eComposant pComposant = Composant(i, Marque);
if ((pComposant != null) && pComposant.EstInitialise && TypeDeFichier.HasFlag(pComposant.TypeDuModele))
pListeComposants.Add(pComposant);
}
return pListeComposants;
}
/// <summary>
/// Méthode privée.
/// Méthode récursive permettant de traverser tous les composants d'une pièce ou d'un assemblage
/// </summary>
/// <param name="ComposantRacine"></param>
/// <param name="TypeComposant"></param>
/// <param name="DicComposants"></param>
/// <param name="NomComposant"></param>
private void RecListerComposants(eComposant ComposantRacine, TypeFichier_e TypeComposant, Dictionary<String, eComposant> DicComposants, String NomComposant = "")
{
Log.Methode(cNOMCLASSE);
foreach (eComposant pComp in ComposantRacine.ComposantsEnfants("", _PrendreEnCompteSupprime))
{
// Operateur "Implique" sur la propriété EstExclu
if (!pComp.EstExclu | _PrendreEnCompteExclus)
{
// Attention, Regex.IsMatch peut renvoyer une erreur si NomComposant est égal à un caractère spécial
// du style "*" ou "[" et autre. Pb à corriger.
if (TypeComposant.HasFlag(pComp.Modele.TypeDuModele) && Regex.IsMatch(pComp.Modele.FichierSw.Chemin, NomComposant))
{
eComposant pComposant = new eComposant();
String pCle = NomCle(pComp);
Log.Message("Clé : " + pCle);
// S'il est déjà dans le dico, on on rajoute 1
if (DicComposants.ContainsKey(pCle))
{
pComposant = DicComposants[pCle];
pComposant.Nb += 1;
}
// sinon on le rajoute
else
{
// Si on supprime les doublons et que l'on ne prend pas e compte les configs, on associe au modèle le composant racine
// et non le composant de l'assemblage
if (_SupprimerDoublons && !_PrendreEnCompteConfig)
{
eModele pModele = pComp.Modele;
pModele.ReinitialiserComposant();
pComposant = pModele.Composant;
}
else
{
pComposant = pComp;
}
pComposant.Nb = 1;
DicComposants.Add(pCle, pComposant);
}
}
// Si c'est un assemblage et qu'il n'est pas supprimé, on scan
if ((pComp.Modele.TypeDuModele == TypeFichier_e.cAssemblage) && (pComp.EstSupprime == false))
{
RecListerComposants(pComp, TypeComposant, DicComposants, NomComposant);
}
}
}
}
/// <summary>
/// Renvoi la liste des ExtFichierSW filtrées par les arguments
/// Permet de lister les fichiers sans faire de liens avec les composants SW et donc de pouvoir
/// fermer le composant racine pour ensuite travailler sur les fichiers.
/// Cela permet d'accélérer le traitement des fichiers.
/// </summary>
/// <param name="TypeComposant"></param>
/// <param name="NomComposant"></param>
/// <returns></returns>
public ArrayList ListeFichiers(TypeFichier_e TypeComposant, String NomComposant = "")
{
Log.Methode(cNOMCLASSE);
ArrayList pListeComps = ListeComposants(TypeComposant, NomComposant);
ArrayList pArrayComps = new ArrayList();
if (pListeComps.Count > 0)
{
foreach (eComposant pComp in pListeComps)
{
eFichierSW pFichier = new eFichierSW();
if (pFichier.Init(_Composant.Modele.SW))
{
pFichier.Chemin = pComp.Modele.FichierSw.Chemin;
pFichier.Configuration = pComp.Configuration.Nom;
pFichier.Nb = pComp.Nb;
pArrayComps.Add(pFichier);
}
}
}
return pArrayComps;
}
/// <summary>
/// Méthode interne
/// Renvoi la liste des composants filtrées par les arguments
/// </summary>
/// <param name="TypeComposant"></param>
/// <param name="NomComposant"></param>
/// <returns></returns>
public ArrayList ListeComposants(TypeFichier_e TypeComposant, String NomComposant = "")
{
Log.Methode(cNOMCLASSE);
Dictionary<String, eComposant> pDicComposants = new Dictionary<string, eComposant>();
// On met l'index à 0
_IndexComposant = 0;
// On renvoi le composant de base
if ((_RenvoyerComposantRacine == true) && TypeComposant.HasFlag(_Composant.Modele.TypeDuModele))
{
// On renvoi un composant par config
if (_PrendreEnCompteConfig && _RenvoyerConfigComposantRacine)
{
foreach (eConfiguration pConfig in _Composant.Modele.GestDeConfigurations.ListerLesConfigs(TypeConfig_e.cDeBase))
{
Component2 pSwComp = pConfig.SwConfiguration.GetRootComponent3(false);
eModele pModele = _Composant.Modele.SW.Modele(pSwComp.GetPathName());
eComposant pComp = new eComposant();
pComp.Init(pSwComp, pModele);
pModele.Composant = pComp;
pComp.Configuration = pConfig;
pDicComposants.Add(NomCle(pComp), pComp);
}
}
else
pDicComposants.Add(NomCle(_Composant), _Composant);
}
// Si le composant est un assemblage contenant plusieurs composants, on renvoi la liste des composants recherchés
if ((_Composant.Modele.TypeDuModele == TypeFichier_e.cAssemblage) && (_Composant.SwComposant.IGetChildrenCount() > 0))
RecListerComposants(_Composant, TypeComposant, pDicComposants, NomComposant);
// Nouvelle liste à renvoyer
ArrayList pListeComposants = new ArrayList();
// Si le dictionnaire n'est pas vide, on rempli la liste avec les valeurs du dictionnaire
if (pDicComposants.Count > 0)
pListeComposants = new ArrayList(pDicComposants.Values);
// On trie et c'est parti
//pListeComposants.Sort();
return pListeComposants;
}
/// <summary>
/// Creer un document
/// </summary>
/// <param name="Dossier"></param>
/// <param name="NomDuDocument"></param>
/// <param name="TypeDeDocument"></param>
/// <param name="Gabarit"></param>
/// <returns></returns>
public eModele CreerDocument(String Dossier, String NomDuDocument, TypeFichier_e TypeDeDocument, String Gabarit = "")
{
eModele pModele = new eModele();
ModelDoc2 pSwModele;
String pCheminGabarit = "";
if (String.IsNullOrEmpty(Gabarit))
{
switch (TypeDeDocument)
{
case TypeFichier_e.cAssemblage:
pCheminGabarit = _SwSW.GetUserPreferenceStringValue((int)swUserPreferenceStringValue_e.swDefaultTemplateAssembly);
break;
case TypeFichier_e.cPiece:
pCheminGabarit = _SwSW.GetUserPreferenceStringValue((int)swUserPreferenceStringValue_e.swDefaultTemplatePart);
break;
case TypeFichier_e.cDessin:
pCheminGabarit = _SwSW.GetUserPreferenceStringValue((int)swUserPreferenceStringValue_e.swDefaultTemplateDrawing);
break;
}
}
else
{
String[] pTabCheminsGabarit = _SwSW.GetUserPreferenceStringValue((int)swUserPreferenceStringValue_e.swFileLocationsDocumentTemplates).Split(';');
foreach (String Chemin in pTabCheminsGabarit)
{
pCheminGabarit = Chemin + @"\" + Gabarit + CONSTANTES.InfoFichier(TypeDeDocument, InfoFichier_e.cGabarit);
if (File.Exists(pCheminGabarit))
break;
}
}
int Format = 0;
Double Lg = 0;
Double Ht = 0;
if (TypeDeDocument == TypeFichier_e.cDessin)
{
Double[] pTab = _SwSW.GetTemplateSizes(pCheminGabarit);
Format = (int)pTab[0];
Lg = pTab[1];
Ht = pTab[2];
}
Log.Message(Format.ToString());
Log.Message(Lg.ToString());
Log.Message(Ht.ToString());
pSwModele = _SwSW.NewDocument(pCheminGabarit, Format, Lg, Ht);
pSwModele.Extension.SaveAs(Dossier + @"\" + NomDuDocument + CONSTANTES.InfoFichier(TypeDeDocument),
(int)swSaveAsVersion_e.swSaveAsCurrentVersion,
(int)swSaveAsOptions_e.swSaveAsOptions_Silent,
null,
ref Erreur,
ref Warning);
if (pModele.Init(pSwModele, this))
return pModele;
return null;
}
