Ejemplo n.º 1
0
static int SubmoduleCallback(git_submodule *sm, const char * /*name*/, void *payload)
{
    auto spayload = (SubmodulePayload *)payload;
    CString path = CUnicodeUtils::GetUnicode(git_submodule_path(sm));
    if (spayload->prefixList.empty())
    {
        CTGitPath subPath(spayload->basePath);
        subPath.AppendPathString(path);
        spayload->list.push_back(subPath.GetGitPathString());
        SubmodulePayload tpayload(spayload->list, subPath.GetGitPathString());
        GetSubmodulePathList(tpayload);
    }
    else
    {
        for (size_t i = 0; i < spayload->prefixList.size(); ++i)
        {
            CString prefix = spayload->prefixList.at(i) + _T("/");
            if (path.Left(prefix.GetLength()) == prefix)
            {
                CTGitPath subPath(spayload->basePath);
                subPath.AppendPathString(path);
                spayload->list.push_back(subPath.GetGitPathString());
                SubmodulePayload tpayload(spayload->list, subPath.GetGitPathString());
                GetSubmodulePathList(tpayload);
            }
        }
    }
    return 0;
}
Ejemplo n.º 2
0
void MltRuntime::parse_struct(json_t* v, const JsonPath& curPath,
		hash_map<string, JsonPath>& uuid_paths, int erase) throw(Exception)
{
	json_t* je = json_object_get(v, "uuid");
	if ( je && json_is_string(je) && strlen(json_string_value(je)) ) {
		string uuid = json_string_value(je);
		if (!erase) {
			if ( uuid_paths.find(uuid) != uuid_paths.end()) {
				throw_error_v(ErrorRuntimeJsonUUIDDup, "uuid dup:%s", uuid.c_str());
			}
			uuid_paths[uuid] = curPath;
		}
		else {
			uuid_paths.erase(string(uuid));
		}
	}

	void* it =  json_object_iter(v);
	while(it) {
		const char* k = json_object_iter_key(it);
		je = json_object_iter_value(it);
		it = json_object_iter_next(v, it);

		if ( json_is_object(je) && json_object_size(je) > 0 ) {
			JsonPath subPath(curPath);
			subPath.push_back(k);
			parse_struct(je, subPath, uuid_paths, erase);
		}
		else if (json_is_array(je) && json_array_size(je) > 0) {
			int sz = json_array_size(je);
			for ( int i=0; i<sz; i++ ) {
				json_t* ae = json_array_get(je, i);
				if ( json_is_object(ae) && json_object_size(ae) > 0 ) {
					JsonPath subPath(curPath);
					subPath.push_back(k, i);
					parse_struct(ae, subPath, uuid_paths, erase);
				}
			}
		}
	}
}
Ejemplo n.º 3
0
ossimRefPtr<ossimXmlNode> ossimXmlNode::addNode(const ossimString& relPath,
        const ossimString& text)
{
    //
    // Make a copy to manipulate:
    //
    ossimString relXpath (relPath);
    if (relXpath.empty())
        return 0;

    //
    // First verify that this is not an absolute path:
    //
    if (relXpath[static_cast<std::string::size_type>(0)] ==
            XPATH_DELIM[static_cast<std::string::size_type>(0)])
    {
        ossimNotify(ossimNotifyLevel_WARN) << "WARNING: ossimXmlNode::findChildNodes\n"
                                           << "Only relative XPaths can be searched from a node. "
                                           << "Returning null list...\n";
        return 0;
    }

    //
    // Read the desired tag from the relative xpath
    //
    ossimString desiredTag (relXpath);
    if (relXpath.contains(XPATH_DELIM))
    {
        desiredTag = relXpath.before(XPATH_DELIM);
    }
    ossimString subPath (relXpath.after(XPATH_DELIM));

    ossimRefPtr<ossimXmlNode> node = findFirstNode(desiredTag);

    if(!node.valid())
    {
        if(subPath.empty())
        {
            node = addChildNode(desiredTag, text);
        }
        else
        {
            node = addChildNode(desiredTag, "");
        }
    }
    if(!subPath.empty())
    {
        return node->addNode(subPath, text);
    }

    return node;
}
Ejemplo n.º 4
0
QList<unsigned int> GLC_WorldTo3dxml::instancePath(const GLC_StructOccurence* pOccurence)
{
	QList<unsigned int> path;
	if (!pOccurence->isOrphan())
	{
		GLC_StructInstance* pInstance= pOccurence->structInstance();
		Q_ASSERT(m_InstanceToIdHash.contains(pInstance));
		path.prepend(m_InstanceToIdHash.value(pInstance));
		QList<unsigned int> subPath(instancePath(pOccurence->parent()));
		subPath.append(path);
		path= subPath;
	}
	return path;
}
void
trimSurface()
{								  
    AcBr::ErrorStatus returnValue = AcBr::eOk;
    Acad::ErrorStatus acadReturnValue = eOk;

    // Get the subentity path for a face
	AcDbFullSubentPath subPath(kNullSubent);
	acadReturnValue = selectEntity(AcDb::kFaceSubentType, subPath);
	if (acadReturnValue != eOk) {
		acutPrintf(ACRX_T("\n Error in getPath: %d"), acadReturnValue);
		return;
	}

	// Make a face entity to access the surface
	AcBrFace faceEntity;
	returnValue = faceEntity.set(subPath);
	if (returnValue != AcBr::eOk) {
		acutPrintf(ACRX_T("\n Error in AcBrFace::set:"));
		errorReport(returnValue);
		return;
	}

	// Query the style for trimmed surface dump
	Adesk::Boolean trimmed = Adesk::kTrue;
    ACHAR opt[128];
   	while (Adesk::kTrue) {
		acutPrintf(ACRX_T("\nSelect Style for Trimmed Surface Dump: "));
		acedInitGet(NULL, ACRX_T("Nurb Trimmed"));
		if (acedGetKword(ACRX_T("Nurb/<Trimmed>: "), opt) == RTCAN) return;

        // Map the user input to a valid dump style
		if ((_tcscmp(opt, ACRX_T("Trimmed")) == 0) || (_tcscmp(opt, ACRX_T("")) == 0)) {
            trimmed = Adesk::kTrue;
            break;
        } else if ((_tcscmp(opt, ACRX_T("Nurb")) == 0)) {
            trimmed = Adesk::kFalse;
            break;
	    }
    }

	(trimmed) ? faceToTrimmedSurface(faceEntity) : faceToNurbSurface(faceEntity);

	return;
}
AcBr::ErrorStatus
selectEntityByType(AcBrEntity*& pEnt, AcDb::SubentType& subType)
{
	Acad::ErrorStatus acadReturnValue = Acad::eOk;
	AcBr::ErrorStatus returnValue = AcBr::eOk;

	// Query validation level
	AcBr::ValidationLevel vlevel = validationLevel();

	// Query the subentity type
	subType = subtype();

	// Query whether to select a database entity or create a new one
	Adesk::Boolean context = (subType != AcDb::kNullSubentType)
		? Adesk::kFalse : localContext();

	if (!context) {
		// Query the subentity by AutoCAD pick and get the subentity path
		AcDbFullSubentPath subPath(kNullSubent);
		acadReturnValue = selectEntity(subType, subPath);
		if (acadReturnValue != Acad::eOk) {
			acutPrintf(ACRX_T("\n Error in selectEntity: %d"), acadReturnValue);
			return (AcBr::ErrorStatus)acadReturnValue;
		}

		// Call the appropriate subentity constructor
		switch (subType) {
		case AcDb::kNullSubentType:
    		pEnt = new AcBrBrep();
			break;
		case AcDb::kFaceSubentType:
    		pEnt = new AcBrFace();
			break;
		case AcDb::kEdgeSubentType:
    		pEnt = new AcBrEdge();
			break;  
		default:
			acutPrintf(ACRX_T("\n selectEntityByType: unsupported subentity type: %d\n"), subType);
			returnValue = (AcBr::ErrorStatus)Acad::eWrongSubentityType;
			return returnValue;
		}
		if (pEnt == NULL) {
			acutPrintf(ACRX_T("\n selectEntityByType: unable to allocate memory\n"));
			returnValue = (AcBr::ErrorStatus)Acad::eOutOfMemory;
			return returnValue;
		}

		returnValue = pEnt->set(subPath);
		if (returnValue != AcBr::eOk) {
    		acutPrintf(ACRX_T("\n Error in AcBrEntity::set:"));
    		errorReport(returnValue);
    		return returnValue;
		}
	} else {
		// Create the entity as a local object
		AcDbEntity* pEntity;
		acadReturnValue = createEntity(pEntity);
		if (acadReturnValue != Acad::eOk) {
			acutPrintf(ACRX_T("\n Error in createEntity: %d"), acadReturnValue);
			return (AcBr::ErrorStatus)acadReturnValue;
		}
		if (pEntity == NULL) {
			acutPrintf(ACRX_T("\n selectEntityByType: unable to allocate memory\n"));
			returnValue = (AcBr::ErrorStatus)Acad::eOutOfMemory;
			return returnValue;
		}

    	pEnt = new AcBrBrep();
		if (pEnt == NULL) {
			acutPrintf(ACRX_T("\n selectEntityByType: unable to allocate memory\n"));
			returnValue = (AcBr::ErrorStatus)Acad::eOutOfMemory;
			return returnValue;
		}

		returnValue = ((AcBrBrep*)pEnt)->set((const AcDbEntity&)*pEntity);
		if (returnValue != AcBr::eOk) {
    		acutPrintf(ACRX_T("\n Error in AcBrEntity::set:"));
    		errorReport(returnValue);
    		return returnValue;
		}
	}

	returnValue = pEnt->setValidationLevel(vlevel);
	if (returnValue != AcBr::eOk) {
    	acutPrintf(ACRX_T("\n Error in AcBrEntity::setValidationLevel:"));
    	errorReport(returnValue);
    	return returnValue;
	}

	return returnValue;
}
Ejemplo n.º 7
0
ParsedPath::operator PathName() const
{
	if (!getCount())
		return "";
	return subPath(getCount());
}
Ejemplo n.º 8
0
// Recursive routine to get all subdirs added
BOOL CAddListDlg::AddPath(CStringList *pList, LPCTSTR path)
{
	BOOL success=TRUE;
    	
	// Process any accumulated messages
	if (!MainFrame()->IsQuitting())
	{
		MSG msg;
		while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				// App was just terminated
				return FALSE;

			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	// Is path a directory or a file?
	WIN32_FIND_DATA fileInfo;
	HANDLE hFile=FindFirstFile(path, &fileInfo);
	if(hFile == INVALID_HANDLE_VALUE)
	{
		success= FALSE;
		goto ReportErrors;
	}

	FindClose(hFile);
	
	if( (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)
	{
		// Its a file, so just add the one file
		pList->AddHead(path);
		m_AddFileCount++;

        // Every m_WarnLimit, check with user to see if we are out of 
        // control.
		if(m_WarnLimit && (m_AddFileCount%m_WarnLimit) == 0 )
		{
            if(VerifyOKToContinue() != IDYES)
            {
			    success=FALSE;
                m_UserTerminated=TRUE;
			    goto ReportErrors;
            }
			if (m_WarnLimit < 10)
				m_WarnLimit = 5000;
        }
	}
	else
	{
		// Its a directory, so enumerate its contents
		CString subPath(path);
		subPath += _T("\\*.*");
		
		hFile=FindFirstFile(subPath, &fileInfo);
		if(hFile == INVALID_HANDLE_VALUE)
		{
			success= FALSE;
			goto ReportErrors;
		}
		
		CString fullName;
		while(1)
		{
			if(lstrcmp(fileInfo.cFileName, _T(".")) !=0 && lstrcmp(fileInfo.cFileName, _T("..")) !=0)
			{
				fullName=path;
				fullName += _T("\\");
				fullName += fileInfo.cFileName;
				if( (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)
				{
					// Add files directly
					pList->AddHead(fullName);
					m_AddFileCount++;
					if( (m_AddFileCount%m_WarnLimit) == 0 &&
                        VerifyOKToContinue() != IDYES )
					{	
						success=FALSE;
                        m_UserTerminated=TRUE;
						break;
					}
				}
				else
				{
					// Make a recursive call to AddPath for directories
					if(!AddPath(pList, fullName))
					{
						success=FALSE;
						break;
					}
				}
			}
			if( !FindNextFile(hFile, &fileInfo) )
				break;
		}	
		FindClose(hFile);
	}

ReportErrors:

	if(!success && !m_UserTerminated)
	{
		DWORD errNo=GetLastError();
		if(errNo != 0)  // Avoid showing same message too many times
		{
		    LPVOID lpMsgBuf;
			FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
				NULL,  errNo, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
				(LPTSTR) &lpMsgBuf, 0, NULL );
			// Display the string.
			CString msg = (LPCTSTR)lpMsgBuf;
			if (errNo == 0x7B)
			{
				CString p = path;
				if (p.ReverseFind(_T(':')) != 1)
					msg += LoadStringResource(IDS_CANTADDLNKVIAFILEADD);
			}
			AfxMessageBox(msg + _T('\n') + path, MB_OK|MB_ICONERROR );

            // Free the buffer.
			LocalFree( lpMsgBuf );
			SetLastError(0);
		}
	}

	return success;
}
Ejemplo n.º 9
0
std::vector<FileData> getFileDataFrom(const FS_NAMESPACE::path & inPath, const FS_NAMESPACE::path & outPath, const FS_NAMESPACE::path & parentDir, const bool recurse)
{
	// get all files from directory
	std::vector<FileData> files;
	// check for infinite symlinks
	if (FS_NAMESPACE::is_symlink(inPath))
	{
		// check if the symlink points somewhere in the path. this would recurse
		if (inPath.string().find(FS_NAMESPACE::canonical(inPath).string()) == 0)
		{
			std::cout << "Warning: Path " << inPath << " contains recursive symlink! Skipping." << std::endl;
			return files;
		}
	}
	// iterate through source directory searching for files
	const FS_NAMESPACE::directory_iterator dirEnd;
	for (FS_NAMESPACE::directory_iterator fileIt(inPath); fileIt != dirEnd; ++fileIt)
	{
		FS_NAMESPACE::path filePath = (*fileIt).path();
		if (!FS_NAMESPACE::is_directory(filePath))
		{
			if (beVerbose)
			{
				std::cout << "Found input file " << filePath << std::endl;
			}
			// add file to list
			FileData temp;
			temp.inPath = filePath;
			// replace dots in file name with '_' and add a .c/.cpp extension
			std::string newFileName = filePath.filename().generic_string();
			std::replace(newFileName.begin(), newFileName.end(), '.', '_');
			if (useC)
			{
				newFileName.append(".c");
			}
			else
			{
				newFileName.append(".cpp");
			}
			// remove parent directory of file from path for internal name. This could surely be done in a safer way
			FS_NAMESPACE::path subPath(filePath.generic_string().substr(parentDir.generic_string().size() + 1));
			// add a ":/" before the name to mark internal resources (Yes. Hello Qt!)
			temp.internalName = ":/" + subPath.generic_string();
			// add subdir below parent path to name to enable multiple files with the same name
			std::string subDirString(subPath.remove_filename().generic_string());
			if (!subDirString.empty())
			{
				// replace dir separators by underscores
				std::replace(subDirString.begin(), subDirString.end(), '/', '_');
				// add in front of file name
				newFileName = subDirString + "_" + newFileName;
			}
			// build new output file name
			temp.outPath = outPath / newFileName;
			if (beVerbose)
			{
				std::cout << "Internal name will be \"" << temp.internalName << "\"" << std::endl;
				std::cout << "Output path is " << temp.outPath << std::endl;
			}
			// get file size
			try
			{
				temp.size = static_cast<uint64_t>(FS_NAMESPACE::file_size(filePath));
				if (beVerbose)
				{
					std::cout << "Size is " << temp.size << " bytes." << std::endl;
				}
			}
			catch (...)
			{
				std::cout << "Error: Failed to get size of " << filePath << "!" << std::endl;
				temp.size = 0;
			}
			// add file to list
			files.push_back(temp);
		}
	}
	// does the user want subdirectories?
	if (recurse)
	{
		// iterate through source directory again searching for directories
		for (FS_NAMESPACE::directory_iterator dirIt(inPath); dirIt != dirEnd; ++dirIt)
		{
			FS_NAMESPACE::path dirPath = (*dirIt).path();
			if (FS_NAMESPACE::is_directory(dirPath))
			{
				if (beVerbose)
				{
					std::cout << "Found subdirectory " << dirPath << std::endl;
				}
				// subdirectory found. recurse.
				std::vector<FileData> subFiles = getFileDataFrom(dirPath, outPath, parentDir, recurse);
				// add returned result to file list
				files.insert(files.end(), subFiles.cbegin(), subFiles.cend());
			}
		}
	}
	// return result
	return files;
}
Ejemplo n.º 10
0
// -------------------------------------------------------------
void Actions::ParseDirectory( LPCTSTR rootPath, LPCTSTR extentionPath  )
{
  // make sure that we do not have too many actions
  // this is a sign that something is broken
  // or that we are reading the root directory
  {
    myodd::threads::Lock guard(_mutexActions);
    if (_actions.size() > static_cast<size_t>(::myodd::config::Get(L"paths\\maxcommand", 2048)))
    {
      ASSERT(0); // you have reached the limit!
                   // it is pointless to try and add more command.
      return;
    }
  }

  // make sure that the path that we have is valid.
  ASSERT( _tcslen( rootPath ) > 0 );
  if( _tcslen( rootPath ) == 0 )
  {
    return;
  }

  //  the end path
  std::wstring directory = rootPath;  

  // make sure it has a trailing back slash.
  myodd::files::AddTrailingBackSlash( directory );

  // add the extension
  directory += extentionPath;

  //  add a trailing back slash
  myodd::files::AddTrailingBackSlash( directory );

  //
  //  we could refine the search to
  //  *.bat, *.exe, *.pl
  //  but I am not sure we really need to restrict anything
  // it is up to the user to ensure that they have 
  auto sPath = directory + L"*.*";

  LPTSTR fullPath = NULL;
  if( !myodd::files::ExpandEnvironment( sPath.c_str(), fullPath ) )
  {
    return;
  }
  
  _tfinddata_t fdata;
  const auto ffhandle = _tfindfirst( fullPath, &fdata );
  if( ffhandle != -1 )
  {
    do
    {
      if( _tcscmp(fdata.name, L"." ) == 0 || _tcscmp(fdata.name, L"..") == 0)
      {
        continue;
      }

      //  .svn directories are hidden so we might as well ignore all hidden file.
      if( (fdata.attrib & _A_HIDDEN) == _A_HIDDEN )
      {
        continue;
      }

      if( (fdata.attrib & _A_SUBDIR) == _A_SUBDIR )
      {
        if( IsReservedDir( fdata.name ) )
        {
          continue;
        }
        
        std::wstring subPath( extentionPath );
        subPath += fdata.name;
        myodd::files::AddTrailingBackSlash( subPath );

        ParseDirectory( rootPath, subPath.c_str() );
        continue;
      }

      //  ok add this command
      auto szFullPath( directory);
      szFullPath += fdata.name;

      std::wstring szName( fdata.name);
      szName = myodd::strings::lower(szName );
      
      //  if we don't want to show the extension then strip it.
      if( ::myodd::config::Get( L"commands\\show.extentions", 0 ) == false )
      {
        myodd::files::StripExtension( szName );
      }        

      Add( new Action( _application ,szName, szFullPath));
    }while( _tfindnext( ffhandle, &fdata ) == 0 );

    _findclose( ffhandle );
  }

  delete [] fullPath;
}
Ejemplo n.º 11
0
void
countSubents()
{
    AcBr::ErrorStatus returnValue = AcBr::eOk;
    Acad::ErrorStatus acadReturnValue = eOk;

    // Get the subentity path for a brep
	AcDbFullSubentPath subPath(kNullSubent);
	acadReturnValue = selectEntity(AcDb::kNullSubentType, subPath);
	if (acadReturnValue != eOk) {
		acutPrintf(ACRX_T("\n Error in getPath: %d"), acadReturnValue);
		return;
	}

	// Make a brep entity to access the solid
	AcBrBrep brepEntity;
	returnValue = ((AcBrEntity*)&brepEntity)->set(subPath);
	if (returnValue != AcBr::eOk) {
		acutPrintf(ACRX_T("\n Error in AcBrBrep::set:"));
		errorReport(returnValue);
		return;
	}

	// count the unique complexes in the brep
	returnValue = countComplexes(brepEntity);
	if (returnValue != AcBr::eOk) {
		acutPrintf(ACRX_T("\n Error in countComplexes:"));
		errorReport(returnValue);
		return;
	}

	// count the unique shells in the brep
	returnValue = countShells(brepEntity);
	if (returnValue != AcBr::eOk) {
		acutPrintf(ACRX_T("\n Error in countShells:"));
		errorReport(returnValue);
		return;
	}

	// count the unique faces in the brep
	returnValue = countFaces(brepEntity);
	if (returnValue != AcBr::eOk) {
		acutPrintf(ACRX_T("\n Error in countFaces:"));
		errorReport(returnValue);
		return;
	}

	// count the unique edges in the brep
	returnValue = countEdges(brepEntity);
	if (returnValue != AcBr::eOk) {
		acutPrintf(ACRX_T("\n Error in countEdges:"));
		errorReport(returnValue);
		return;
	}

	// count the unique vertices in the brep
	returnValue = countVertices(brepEntity);
	if (returnValue != AcBr::eOk) {
		acutPrintf(ACRX_T("\n Error in countVertices:"));
		errorReport(returnValue);
		return;
	}

	return;
}
Ejemplo n.º 12
0
void Builder::run()
{
    VLM_LatestError = BUILDER_NO_ERROR;
    //InterfaceArchiver * archives =new InterfaceArchiver();
    QString MCL_CurrentFilePath = "";
    int count;
    QFile VXL_UpdateListFile(VCM_OutputFilePath);
    QFileInfo VXL_UpdateListFileInfo;
    QDir VXL_UpdateListDir;
    //On vérirife l'existence du dossier
    VXL_UpdateListFileInfo.setFile(VXL_UpdateListFile);
    VXL_UpdateListDir = VXL_UpdateListFileInfo.absoluteDir();
    if(!VXL_UpdateListDir.exists())
    {
       VXL_UpdateListDir.mkpath(VXL_UpdateListFileInfo.absolutePath());
    }
    else
    {
        //On vérifie la présence du fichier
        if(VXL_UpdateListFile.exists())
        {
            //On le supprime
            VXL_UpdateListFile.remove();
        }
    }

    //On ouvre le fichier
    if (!VXL_UpdateListFile.open(QIODevice::WriteOnly | QIODevice::Text))
    {
            emit NotifyErrorMsg("Unable to open UpdateList File");
            VLM_LatestError = BUILDER_ERROR_CANT_OPEN_FILE;
            return;
    }
    //On créé le buffer pour insèrer du texte
    QTextStream VXL_OutTextStream(&VXL_UpdateListFile);
    count = OMM_ListFilesToTreate.size();
    VXL_OutTextStream << "[files]" <<"\n" << "fcount=" << count << "\n";
    for(int i=0; i<OMM_ListFilesToTreate.size();i++)
    {
        MCL_CurrentFilePath = 	OMM_ListFilesToTreate[i]->getPath() + "/"
                + OMM_ListFilesToTreate[i]->getFilename().section('/', -1);
        qDebug() << MCL_CurrentFilePath;
        //On calcul le hash du fichier
        OMM_ListFilesToTreate[i]->setSha1(CalcSha1(MCL_CurrentFilePath));

        //Si demandé, on affiche le fichier en cours de traitement
        #ifdef ENABLE_DEBUG_SHOWLISTS
            #ifdef QT_DEBUG
                    qDebug()    << "File :" << i+1 << "/" <<OMM_ListFilesToTreate.size()
                                << OMM_ListFilesToTreate[i]->getFilename() 	<< "|"
                                << OMM_ListFilesToTreate[i]->getpriority()	<< "|"
                                << OMM_ListFilesToTreate[i]->getPath()		<< "|"
                                << OMM_ListFilesToTreate[i]->getSha1() ;
            #endif //QT_DEBUG
        #endif //ENABLE_DEBUG_SHOWLISTS

        //On écris la ligne qui le concerne
        if(QString::compare(MCL_CurrentFilePath, VCM_ReferenceFilePath) == 0)
        {//Fichier de référence

        }
        else
        {//Fichier "normal"
                    count++;
            VXL_OutTextStream     << "F"<<i<<"="
            << OMM_ListFilesToTreate[i]->getFilename() 	<< "|"
            << OMM_ListFilesToTreate[i]->getSha1()		<< "|"
            << OMM_ListFilesToTreate[i]->getpriority()
            << "\n";
        }
        /***********TODO****************/
        QString fileToCopy(OMM_ListFilesToTreate[i]->getPath() + "/"
                           + OMM_ListFilesToTreate[i]->getFilename().section('/', -1));
        QString subPath(OMM_ListFilesToTreate[i]->getFilename().section('/', 0, -2));
        VXL_UpdateListDir.mkpath(subPath);
        QFile::copy(fileToCopy, VCM_ReferenceFilePath+OMM_ListFilesToTreate[i]->getFilename());
        // QFile::copy(OMM_ListFilesToTreate[i]->getFilename(),OMM_ListFilesToTreate[i]->getFilename());
        // On Maj la ProgressBar
        emit NotifyProgress(i+1,OMM_ListFilesToTreate.size());
    }
    return;
}