Esempio n. 1
0
        private void SearchThread(object state)
        {
            Regex       regDir        = CPatternMatch.Convert(m_strDirPattern);
            Regex       regFile       = CPatternMatch.Convert(m_strFilePattern);
            CRepertoire repSel        = null;
            CFichier    ficSel        = null;
            CFichier    fichierTrouve = null;

            if (m_formMain != null)
            {
                repSel = m_formMain.GetRepertoireSel();
                ficSel = m_formMain.GetFichierSel();
                if (repSel != null)
                {
                    fichierTrouve = repSel.FindNext(true, repSel, ficSel, regDir, regFile, m_indicateurProgression);
                    if (fichierTrouve != null)
                    {
                        m_formMain.SelectFichier(fichierTrouve);
                    }
                }
            }
            CFormProgression.EndIndicateur(m_indicateurProgression);
            m_threadSearch = null;
            Invoke((MethodInvoker) delegate { UpdateVisuel(); });
            if (fichierTrouve == null)
            {
                MessageBox.Show("Pattern not found");
            }
        }
Esempio n. 2
0
 public void FillFrom(string strPathComplet)
 {
     Nom = Path.GetFileName(strPathComplet);
     foreach (string strDir in Directory.GetDirectories(strPathComplet))
     {
         CRepertoire dossier = GetChilds <CRepertoire>().FirstOrDefault(d => d.Nom == Path.GetFileName(strDir));
         if (dossier == null)
         {
             dossier = new CRepertoire();
         }
         dossier.FillFrom(strDir);
         m_listeElements.Add(dossier);
     }
     foreach (string strFile in Directory.GetFiles(strPathComplet))
     {
         CFichier fichier = GetChilds <CFichier>().FirstOrDefault(fi => fi.Nom == Path.GetFileName(strFile));
         if (fichier == null)
         {
             fichier = new CFichier();
         }
         fichier.Nom = Path.GetFileName(strFile);
         FileInfo f = new FileInfo(strFile);
         fichier.LastModifDate = f.LastWriteTime;
         fichier.Size          = f.Length;
         m_listeElements.Add(fichier);
     }
 }
Esempio n. 3
0
 private void FillItem(ListViewItem item, CFichier fichier)
 {
     item.Text = fichier.Nom;
     item.SubItems.Add(fichier.Size.ToString());
     item.SubItems.Add(fichier.LastModifDate.ToString("G"));
     item.ImageIndex      = GetIndexImageFichier(fichier);
     item.StateImageIndex = item.ImageIndex;
     item.Tag             = fichier;
 }
Esempio n. 4
0
        public CFichier GetFichierSel()
        {
            CFichier fichier = null;

            Invoke((MethodInvoker) delegate
            {
                if (m_wndListeFichiers.SelectedItems.Count > 0)
                {
                    fichier = m_wndListeFichiers.SelectedItems[0].Tag as CFichier;
                }
            });
            return(fichier);
        }
Esempio n. 5
0
        private void ShowInfos(object obj)
        {
            if (obj == null)
            {
                m_panelInfo.Visible = false;
            }
            CRepertoire repertoire = obj as CRepertoire;

            if (repertoire != null)
            {
                m_imageErreur.Image   = m_imagesFichiers.Images[GetIndexImageDossier(repertoire)];
                m_lblTitreErreur.Text = repertoire.Nom;
                m_txtErreur.Text      = repertoire.InfoImport;
            }
            CFichier fichier = obj as CFichier;

            if (fichier != null)
            {
                m_imageErreur.Image   = m_imagesFichiers.Images[GetIndexImageFichier(fichier)];
                m_lblTitreErreur.Text = fichier.Nom;
                if (fichier.KeyObjetAssocie != null && fichier.TypeObjetAssocie != null)
                {
                    m_txtErreur.Text = "Imported to ";
                    CObjetDonneeAIdNumerique objet = null;
                    if (CImportMyanmarConst.ContexteDonnee != null)
                    {
                        try
                        {
                            objet = Activator.CreateInstance(fichier.TypeObjetAssocie, new object[] { CImportMyanmarConst.ContexteDonnee }) as CObjetDonneeAIdNumerique;
                            if (obj != null && objet.ReadIfExists(fichier.KeyObjetAssocie))
                            {
                                m_txtErreur.Text += objet.DescriptionElement;
                            }
                        }
                        catch { }
                    }
                    if (objet == null && fichier.TypeObjetAssocie != null)
                    {
                        m_txtErreur.Text += DynamicClassAttribute.GetNomConvivial(fichier.TypeObjetAssocie);
                    }
                    else
                    {
                        m_txtErreur.Text += " ? ";
                    }
                }
                else
                {
                    m_txtErreur.Text = fichier.InfoImport;
                }
            }
        }
Esempio n. 6
0
 private int GetIndexImageFichier(CFichier fichier)
 {
     if (fichier.HasErreurImport())
     {
         return(5);
     }
     else if (fichier.KeyObjetAssocie != null)
     {
         return(3);
     }
     else
     {
         return(1);
     }
 }
Esempio n. 7
0
        /* public bool FindNext ( string strDirPattern, string strFilePattern )
         * {
         *   TreeNode node = m_arbre.SelectedNode;
         *   if (node == null && m_arbre.Nodes.Count > 0)
         *       node = m_arbre.Nodes[0];
         *   if (node == null)
         *       return false;
         *   Regex regDir = CPatternMatch.Convert(strDirPattern);
         *   Regex regFile = CPatternMatch.Convert(strFilePattern);
         *   CRepertoire repertoireSel = node.Tag as CRepertoire;
         *   CFichier fichierSel = null;
         *   if ( m_wndListeFichiers.SelectedItems.Count > 0 )
         *   {
         *       fichierSel = m_wndListeFichiers.SelectedItems[0].Tag as CFichier;
         *   }
         *   CFichier fichier = repertoireSel.FindNext(true, null, fichierSel, regDir, regFile);
         *   if (fichier != null)
         *   {
         *       SelectFichier(fichier);
         *       return true;
         *   }
         *   else
         *   {
         *       MessageBox.Show("Pattern not found");
         *       return false;
         *   }
         *
         * }*/

        public void SelectFichier(CFichier fichier)
        {
            Invoke((MethodInvoker) delegate
            {
                List <CRepertoire> lstReps = new List <CRepertoire>();
                CRepertoire rep            = fichier.RepertoireContenant;
                while (rep != null)
                {
                    lstReps.Add(rep);
                    rep = rep.RepertoireContenant;
                }
                lstReps.Reverse();
                TreeNodeCollection nodes = m_arbre.Nodes;
                TreeNode nodeParent      = null;
                foreach (CRepertoire childRep in lstReps)
                {
                    nodeParent = FindNode(childRep, nodes);
                    if (nodeParent == null)
                    {
                        break;
                    }
                    nodeParent.Expand();
                    nodes = nodeParent.Nodes;
                }
                if (nodeParent != null)
                {
                    m_arbre.SelectedNode = nodeParent;
                    nodeParent.EnsureVisible();
                    foreach (ListViewItem item in m_wndListeFichiers.Items)
                    {
                        if (item.Tag == fichier)
                        {
                            item.Selected = true;
                            item.EnsureVisible();
                            break;
                        }
                    }
                }
            });
        }
Esempio n. 8
0
        public CFichier FindNext(bool bCanGoUp, CRepertoire repertoireStart, CFichier fichierStart, Regex regExRepertoire, Regex regExFichier, IIndicateurProgression indicateur)
        {
            bool bStartSearch = fichierStart == null;

            if (repertoireStart != null && repertoireStart.RepertoireContenant == null)
            {
                repertoireStart = null;
            }
            if (regExRepertoire.IsMatch(Nom))
            {
                foreach (CFichier fichier in GetChilds <CFichier>())
                {
                    if (fichier == fichierStart)
                    {
                        bStartSearch = true;
                        continue;
                    }
                    if (!bStartSearch)
                    {
                        continue;
                    }
                    if (regExFichier.IsMatch(fichier.Nom))
                    {
                        return(fichier);
                    }
                }
            }
            if (RepertoireContenant == null && indicateur != null)
            {
                indicateur.SetBornesSegment(0, GetChilds <CRepertoire>().Count());
            }
            int nIndex = 0;

            bStartSearch = repertoireStart == null;
            foreach (CRepertoire rep in GetChilds <CRepertoire>())
            {
                if (RepertoireContenant == null)
                {
                    indicateur.SetInfo(rep.Nom);
                    nIndex++;
                    indicateur.SetValue(nIndex);
                }
                if (rep == repertoireStart)
                {
                    bStartSearch = true;
                    continue;
                }
                if (!bStartSearch)
                {
                    continue;
                }
                CFichier trouve = rep.FindNext(false, null, null, regExRepertoire, regExFichier, indicateur);
                if (trouve != null)
                {
                    return(trouve);
                }
                if (indicateur.CancelRequest)
                {
                    return(null);
                }
            }
            if (RepertoireContenant != null && bCanGoUp)
            {
                return(RepertoireContenant.FindNext(true, this, null, regExRepertoire, regExFichier, indicateur));
            }
            return(null);
        }