Exemplo n.º 1
0
    inline void DoRecurse(TArchiveWriter& w, Stroka off) const {
        {
            TFileList fl;

            const char* name;
            const Stroka p = Path + off;

            fl.Fill(~p);

            while ((name = fl.Next())) {
                const Stroka fname = p + name;
                const Stroka rname = Prefix + off + name;

                Append(w, fname, rname);
            }
        }

        if (Recursive) {
            TDirsList dl;

            const char* name;
            const Stroka p = Path + off;

            dl.Fill(~p);

            while ((name = dl.Next())) {
                if (strcmp(name, ".") && strcmp(name, "..")) {
                    DoRecurse(w, off + name + "/");
                }
            }
        }
    }
Exemplo n.º 2
0
void mtlrchApp::EvDropFiles (TDropInfo drop)
{
    // Number of files dropped.
    int totalNumberOfFiles = drop.DragQueryFileCount();

    TFileList* files = new TFileList;

    for (int i = 0; i < totalNumberOfFiles; i++) {
        // Tell DragQueryFile the file interested in (i) and the length of your buffer.
        int     fileLength = drop.DragQueryFileNameLen(i) + 1;
        char    *fileName = new char[fileLength];

        drop.DragQueryFile(i, fileName, fileLength);

        // Getting the file dropped. The location is relative to your client coordinates,
        // and will have negative values if dropped in the non client parts of the window.
        //
        // DragQueryPoint copies that point where the file was dropped and returns whether
        // or not the point is in the client area.  Regardless of whether or not the file
        // is dropped in the client or non-client area of the window, you will still receive
        // the file name.
        TPoint  point;
        BOOL    inClientArea = drop.DragQueryPoint(point);
        files->Add(new TFileDrop(fileName, point, inClientArea, this));
    }

    // Open the files that were dropped.
    AddFiles(files);

    // Release the memory allocated for this handle with DragFinish.
    drop.DragFinish();
}
Exemplo n.º 3
0
bool __fastcall TEditTiffForm::PrintFile(void) {
//-------------------------------------------------------------------------------
//             Печатает файл tic.Filename и кладет его в tb->Images             |
// Если что не получилось, то выдает сообщение и возвращает false               |
//-------------------------------------------------------------------------------
    bool res;

    TFileList *ffl = new TFileList;
    String aFiln = ErasePathFromFiln(tic.Filename);
    ffl->Append("", tic.Filename, "", "");

    String filn;
    int filn_n;
    char buf[50], path[300];

    filn = CreateTempFiln();

    Visible = false;
    res = SEnumMainForm->PrintFilesLoaded(filn.c_str(), ffl, 0, 0);
    delete ffl;
    Visible = true;
    if (!res) return false;

    res = tb->LoadTiff(filn);
    DeleteFile(filn);

    return true;
}
Exemplo n.º 4
0
// tests one by one touching each runtime modifiable source file
// returns the number of errors - 0 if all passed.
int RuntimeObjectSystem::TestBuildAllRuntimeSourceFiles(  ITestBuildNotifier* callback, bool bTestFileTracking )
{
    if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo("TestBuildAllRuntimeSourceFiles Starting\n"); }
   
    ITestBuildNotifier* failCallbackLocal = callback;
    if( !failCallbackLocal )
    {
        failCallbackLocal = this;
    }

    int numErrors = 0;

    size_t numFilesToBuild = 0;
    for( unsigned short proj = 0; proj < m_Projects.size( ); ++proj )
    {
        numFilesToBuild += m_Projects[ proj ].m_RuntimeFileList.size( );
    }

    if( 0 == numFilesToBuild )
    {
        failCallbackLocal->TestBuildCallback( NULL, TESTBUILDRRESULT_NO_FILES_TO_BUILD );
    }
    
    for( unsigned short proj = 0; proj < m_Projects.size(); ++proj )
    {
        TFileList filesToTest = m_Projects[ proj ].m_RuntimeFileList; // m_RuntimeFileList could change if file content changes (new includes or source dependencies) so make copy to ensure iterators valid.
        for( TFileList::iterator it = filesToTest.begin(); it != filesToTest.end(); ++it )
        {
            const Path& file = *it;
            if( file.Extension() != ".h" ) // exclude headers, use TestBuildAllRuntimeHeaders
            {
                int fileErrors = TestBuildFile( m_pCompilerLogger, this, file, failCallbackLocal, bTestFileTracking );
                if( fileErrors < 0 )
                {
                    // this means exit, and the number of errors is -ve so remove, unless -0xD1E is the response (for no error die)
                    if( fileErrors != -0xD1E )
                    {
                        numErrors -= fileErrors;
                    }
                    return numErrors;
                }
                numErrors += fileErrors;
            }
        }
    }

    if( 0 == numErrors )
    {
        if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo("All Tests Passed\n"); }
    }
    else
    {
        if( m_pCompilerLogger ) { m_pCompilerLogger->LogError("Tests Failed: %d\n", numErrors); }
    }
    return numErrors;
}
FileMonitor::TFileList::iterator FileMonitor::GetWatchedFileEntry( const FileSystemUtils::Path& file, TFileList& fileList )
{
    TFileList::iterator fileIt = fileList.begin();
    TFileList::iterator fileItEnd = fileList.end();
    while (fileIt != fileItEnd && !ArePathsEqual(fileIt->file, file))
    {
        fileIt++;
    }

    return fileIt;
}
Exemplo n.º 6
0
void CCRUDProcessor::ProcessFiles(TFileList &fileList, const char *pSourceDir, const char *pDestDir, bool bRecursive, CCRUDResults &results)
{
	OutputResult("Processing File List..");

	TFileList::iterator curFile = fileList.begin();

	TDateTime timeBegin;
	timeBegin = timeBegin.CurrentDateTime();

	results.m_iFilesFound = 0;
	results.m_iFilesCopied = 0;

    int nTopLevel = fileList.size();

	ResetEvent(m_hStopEvent);
	while ((WaitForSingleObject(m_hStopEvent, 0) == WAIT_TIMEOUT) &&
			(curFile != fileList.end()))
	{
		// Count this file
		++results.m_iFilesFound;

		// Get the source file name
		string curFileName(pSourceDir);
		curFileName += '\\';
		curFileName += *curFile;
		CleanPath(curFileName.begin());

		// Look for new files in this file
        bool bSearchInFile = bRecursive || nTopLevel;
		if (!bSearchInFile || SearchForNewFiles(fileList, curFileName.begin()))
		{
			// Get the destination file name
			string destFileName(pDestDir);
			destFileName += '\\';
			destFileName += *curFile;
			CleanPath(destFileName.begin());

			// Copy it if it needs to be updated
			if (MaybeCopyFile(curFileName.begin(), destFileName.begin()))
				++results.m_iFilesCopied;
		}

        if (nTopLevel)
            --nTopLevel;

		// Go to the next file in the list
		++curFile;

		// Breathe
		Application->ProcessMessages();
	}

	results.m_ProcessingTime = timeBegin.CurrentDateTime() - timeBegin;
}
/** Save result of prediction to file
*/
void SavePredictions(const TFileList& file_list,
                     const TLabels& labels,
                     const string& prediction_file) {
        // Check that list of files and list of labels has equal size
    assert(file_list.size() == labels.size());
        // Open 'prediction_file' for writing
    ofstream stream(prediction_file.c_str());

        // Write file names and labels to stream
    for (size_t image_idx = 0; image_idx < file_list.size(); ++image_idx)
        stream << file_list[image_idx].first << " " << labels[image_idx] << endl;
    stream.close();
}
Exemplo n.º 8
0
bool AddFileToList(TFileList &fileList, const char *pName)
{
	for (TFileList::iterator curFile = fileList.begin(); curFile != fileList.end(); ++curFile)
    {
    	if (stricmp(curFile->begin(), pName) == 0)
        	return false;
	}

	// Ok, add it to the end..
	fileList.push_back(pName);

	return true;
}
Exemplo n.º 9
0
//*************************************************************************
void BeatDetectorApp::NextFile()
{
	roto = 0;
	if(mTrack && mTrack->isPlaying())
	{
		mTrack->enablePcmBuffering(false);
		mTrack->stop();
	}

#ifdef WIN32
	time_t now;
	time(&now);
	int time_int = (int)now;
#else
	timeval now;
	gettimeofday(&now, NULL);
	int time_int = now.tv_sec;
#endif

	Rand r;
	r.seed(time_int);
	int rand_file = r.nextInt(m_FileList.size());
	path my_path = m_FileList[rand_file].path();
	m_CurrentFile = my_path.string();
	
	if(!write_frames)
	{
		mAudioSource = audio::load(m_CurrentFile);
		mTrack = audio::Output::addTrack(mAudioSource, false);
		mTrack->enablePcmBuffering(true);
		mTrack->play();		
	}
	//rot_inc = r.nextFloat(1.5f, 30.0f);
}
/**Load images by list of files 'file_list' and store them in 'data_set'

*/
void LoadImages(const TFileList& file_list, TDataSet* data_set) {
    for (size_t img_idx = 0; img_idx < file_list.size(); ++img_idx) {
            // Create image
        BMP* image = new BMP();
            // Read image from file
        image->ReadFromFile(file_list[img_idx].first.c_str());
            // Add image and it's label to dataset
        data_set->push_back(make_pair(image, file_list[img_idx].second));
    }
}
Exemplo n.º 11
0
void CApplication::initLocales()
{
	boost::locale::generator gen;
	string path = getBasePath().normalize().string() + "/messages";
	gen.add_messages_path(path);

	TExtensionList extensions = boost::assign::list_of (".mo");
	TFileList translations = CFile::find(boost::filesystem::path(path), extensions, TExcludeList(), -1, false);

	vector<string> domains;
	for (TFileList::const_iterator iter = translations.begin(); iter != translations.end(); ++iter) {
		domains.push_back(boost::filesystem::basename(*iter));
	}

	std::unique(domains.begin(), domains.end());
	for (vector<string>::const_iterator iter = domains.begin(); iter != domains.end(); ++iter) {
		gen.add_messages_domain(*iter);
	}

	for (vector<string>::const_iterator iter = _languages.begin(); iter != _languages.end(); ++iter) {
		_locales[*iter] = gen(*iter + ".UTF-8");
	}
}
Exemplo n.º 12
0
int __fastcall ns_Functions::GetFileList(TFileList &FileList, const String &Mask, bool Recursive, int Size) {
  String PathMask=ExtractFilePath(Mask), FileMask=ExtractFileName(Mask);
  TSearchRec F;
  if(!FindFirst(Mask, faAnyFile&~faDirectory, F)) {
    do {
      FileList.push_back((PathMask+F.Name).LowerCase());
      Size += F.Size;
    }
    while(!FindNext(F));
    FindClose(F);
  }
  if(!Recursive) return Size;
  if(!FindFirst(PathMask+"*", faAnyFile, F)) {
    do
      if(F.Attr&faDirectory && F.Name!="." && F.Name!="..")
        Size += GetFileList(FileList, PathMask+F.Name+"\\"+FileMask, Recursive, Size);
    while(!FindNext(F));
    FindClose(F);
  }
  return Size;
}
Exemplo n.º 13
0
FileSystemUtils::Path RuntimeObjectSystem::FindFile( const FileSystemUtils::Path& input )
{
    FileSystemUtils::Path requestedDirectory = input;
    FileSystemUtils::Path filename;
    FileSystemUtils::Path foundFile = input;
    bool bIsFile = input.HasExtension();
    if( bIsFile )
    {
        requestedDirectory = requestedDirectory.ParentPath();
        filename = input.Filename();
    }
    requestedDirectory.ToOSCanonicalCase();
    filename.ToOSCanonicalCase();
    foundFile.ToOSCanonicalCase();

    // Step 1: Try input directory
    if( requestedDirectory.Exists() )
    {
        m_FoundSourceDirectoryMappings[ requestedDirectory ] = requestedDirectory;
    }
    else
    {
        // Step 2: Attempt to find a pre-existing mapping
        bool bFoundMapping = false;
        if( m_FoundSourceDirectoryMappings.size() )
        {
            FileSystemUtils::Path testDir = requestedDirectory;
            FileSystemUtils::Path foundDir;
            unsigned int depth = 0;
            bool bFound = false;
            while( testDir.HasParentPath() )
            {
                TFileMapIterator itrFind = m_FoundSourceDirectoryMappings.find( testDir );
                if( itrFind != m_FoundSourceDirectoryMappings.end() )
                {
                    foundDir = itrFind->second;
                    bFound = true;
                    break;
                }

                testDir = testDir.ParentPath();
                ++depth;
            }

            if( bFound )
            {
                if( depth )
                {
                    // not an exact match
                    FileSystemUtils::Path directory = requestedDirectory;
                    directory.m_string.replace( 0, testDir.m_string.length(), foundDir.m_string );
                    if( directory.Exists() )
                    {
                        foundFile = directory / filename;
                        if( foundFile.Exists() )
                        {
                            m_FoundSourceDirectoryMappings[ requestedDirectory ] = directory;
                            if( m_pCompilerLogger ) {  m_pCompilerLogger->LogInfo( "Found Directory Mapping: %s to %s\n", requestedDirectory.c_str(), directory.c_str() ); }
                            bFoundMapping = true;
                        }
                    }

                }
                else
                {
                    // exact match
                    foundFile = foundDir / filename;
                    bFoundMapping = true;
                }
            }
            
            if( !bFoundMapping )
            {
                // Step 3: Attempt to find a mapping from a known path
                TFileList requestedSubPaths;
                FileSystemUtils::Path requestedSubPath = requestedDirectory;
                while( requestedSubPath.HasParentPath() )
                {
                    requestedSubPaths.push_back( requestedSubPath );
                    requestedSubPath = requestedSubPath.ParentPath();
                }

                TFileMapIterator itr = m_FoundSourceDirectoryMappings.begin();
                while( ( itr != m_FoundSourceDirectoryMappings.end() ) && !bFoundMapping )
                {
                    FileSystemUtils::Path existingPath = itr->second;
                    while( ( existingPath.HasParentPath() ) && !bFoundMapping )
                    {
                        // check all potentials
                        for( size_t i=0; i<requestedSubPaths.size(); ++i )
                        {
                            FileSystemUtils::Path toCheck = existingPath / requestedSubPaths[i].Filename();
                            if( toCheck.Exists() )
                            {
                                // potential mapping
                                FileSystemUtils::Path directory = requestedDirectory;
                                directory.m_string.replace( 0, requestedSubPaths[i].m_string.length(), toCheck.m_string );
                                if( directory.Exists() )
                                {
                                    foundFile = directory / filename;
                                    if( foundFile.Exists() )
                                    {
                                        m_FoundSourceDirectoryMappings[ requestedDirectory ] = directory;
                                        if( m_pCompilerLogger ) {  m_pCompilerLogger->LogInfo( "Found Directory Mapping: %s to %s\n", requestedDirectory.c_str(), directory.c_str() ); }
                                        bFoundMapping = true;
                                        break;
                                    }
                                }
                            }
                        }
                        existingPath = existingPath.ParentPath();
                    }
                    ++itr;
                }
            }
        }
    }

    if( !foundFile.Exists() )
    {
        if( m_pCompilerLogger ) {  m_pCompilerLogger->LogWarning( "Could not find Directory Mapping for: %s\n", input.c_str() ); }
        ++m_NumNotFoundSourceFiles;
    }
    return foundFile;
}
Exemplo n.º 14
0
//*************************************************************************
void BeatDetectorApp::setup()
{	


	// Set up window
	setWindowSize(480, 480);
	
	// Set up OpenGL
	gl::enableAlphaBlending();
	//glBlendFunc(GL_SRC_ALPHA, GL_ONE);
	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	//glEnable(GL_LINE_SMOOTH);
	//glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
	
	if(write_frames)
	{
		setFrameRate(30);
	}
	else
	{
		setFrameRate(60);
	}
	
	// Set line color
	gl::color(Color(1, 1, 1));
	
	// Load and play audio
	//mAudioSource = audio::load(loadResource(RES_SAMPLE));
	//mTrack = audio::Output::addTrack(mAudioSource, false);
	///mTrack->enablePcmBuffering(true);
	//mTrack->play();
	
	// Set init flag
	mFftInit = false;
	
	std::string dir = getHomeDirectory() + "music\\4vis";
	if(exists(dir))
	{
		if(is_directory(dir))
		{
			copy(directory_iterator(dir), directory_iterator(), back_inserter(m_FileList));
		}
	}
	
	for(TFileList::iterator it = m_FileList.begin(); it != m_FileList.end();)
	{
		//std::string str = it->path().native();
		std::string str = it->path().generic_string();
//#ifdef WIN32
//		if(str.rfind(".wav") != -1)
//#else
		if(str.rfind(".mp3") != -1 || str.rfind(".m4a") != -1)
//#endif
		{
			++it;
		}
		else
		{
			it = m_FileList.erase(it);
		}
	}
	
	NextFile();
	
	if(write_frames)
	{
		COpenALSampleManager::StaticInit();
		p_sample = COpenALSampleManager::CreateSample(m_CurrentFile);
	}
}