ldforge: comparison src/file.cpp

-:0060d11e4991
+:843b3dbbd849
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <QMessageBox>
 #include <QFileDialog>
-#include <qprogressbar.h>
 #include <QDir>
-#include <QThread>
+#include <QApplication>
 #include <stdlib.h>
 #include "common.h"
 #include "config.h"
 #include "file.h"
 // =============================================================================
 namespace LDPaths
 {
 	static str pathError;
-	struct
+	struct {
-	{
 		str LDConfigPath;
 		str partsPath, primsPath;
 	} pathInfo;
-	void initPaths ()
+	void initPaths() {
-	{
+		if( !tryConfigure( io_ldpath )) {
-		if( !tryConfigure ( io_ldpath ))
-		{
 			LDrawPathDialog dlg (false);
 			if( !dlg.exec () )
 				exit( 0 );
 			io_ldpath = dlg.filename();
 		}
 	}
-	bool tryConfigure( str path )
+	bool tryConfigure( str path ) {
-	{
 		QDir dir;
-		if( !dir.cd( path ))
+		if( !dir.cd( path )) {
-		{
 			pathError = "Directory does not exist.";
 			return false;
 		}
 		QStringList mustHave = { "LDConfig.ldr", "parts", "p" };
 		QStringList contents = dir.entryList( mustHave );
-		if (contents.size () != mustHave.size ()) {
+		if( contents.size() != mustHave.size() ) {
 			pathError = "Not an LDraw directory! Must<br />have LDConfig.ldr, parts/ and p/.";
 			return false;
 		}
 		pathInfo.partsPath = fmt( "%1" DIRSLASH "parts", path );
 // =============================================================================
 File* openLDrawFile (str relpath, bool subdirs) {
 	print( "%1: Try to open %2\n", __func__, relpath );
 	File* f = new File;
+	str fullPath;
 	// LDraw models use Windows-style path separators. If we're not on Windows,
 	// replace the path separator now before opening any files.
 #ifndef WIN32
 	relpath.replace( "\\", "/" );
 #endif // WIN32
-	if( g_curfile )
+	if( g_curfile ) {
-	{
 		// First, try find the file in the current model's file path. We want a file
 		// in the immediate vicinity of the current model to override stock LDraw stuff.
 		str partpath = fmt ("%1" DIRSLASH "%2", dirname (g_curfile->name ()), relpath);
-		if (f->open (partpath, File::Read))
+		if (f->open (partpath, File::Read)) {
-			return f;
+			return f; }}
-	}
 	if (f->open (relpath, File::Read))
 		return f;
-	str fullPath;
+	// Try with just the LDraw path first
-	if( io_ldpath.value.length() > 0 )
+	fullPath = fmt ("%1" DIRSLASH "%2", io_ldpath, relpath);
-	{
-		// Try with just the LDraw path first
+	if( f->open( fullPath, File::Read ))
-		fullPath = fmt ("%1" DIRSLASH "%2", io_ldpath, relpath);
+		return f;
-		if( f->open( fullPath, File::Read ))
+	if( subdirs ) {
-			return f;
+		// Look in sub-directories: parts and p
+		for( auto subdir : initlist<const str>({ "parts", "p" })) {
-		if( subdirs )
+			fullPath = fmt ("%1" DIRSLASH "%2" DIRSLASH "%3",
-		{
+				io_ldpath, subdir, relpath);
-			// Look in sub-directories: parts and p
-			for( auto subdir : initlist<const str>({ "parts", "p" }))
+			if (f->open (fullPath, File::Read))
-			{
+				return f; }}
-				fullPath = fmt ("%1" DIRSLASH "%2" DIRSLASH "%3",
-					io_ldpath, subdir, relpath);
-				if (f->open (fullPath, File::Read))
-					return f;
-			}
-		}
-	}
 	// Did not find the file.
+	print( "could not find %1\n", relpath );
 	delete f;
 	return null;
 }
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
-void FileLoader::work()
+void FileLoader::start() {
-{
 	setDone( false );
 	setProgress( 0 );
 	abortflag = false;
-	for( str line : *PROP_NAME( file )) {
+	if( concurrent() ) {
+		// Show a progress dialog if we're loading the main file here and move
+		// the actual work to a separate thread as this can be a rather intensive
+		// operation and if we don't respond quickly enough, the program can be
+		// deemed inresponsive.. which is a bad thing.
+		dlg = new OpenProgressDialog (g_win);
+		dlg->setNumLines( lines().size() );
+		dlg->setModal( true );
+		dlg->show();
+		// Connect the loader in so we can show updates
+		connect( this, SIGNAL( workDone() ), dlg, SLOT( accept() )); }
+	else
+		dlg = null;
+	work( 0 );
+}
+void FileLoader::work( ulong i ) {
+	print( "%1: %2\n", this, i );
+	if( abortflag ) {
+		// We were flagged for abortion, so abort.
+		for( LDObject* obj : m_objs )
+			delete obj;
+		m_objs.clear();
+		abortflag = false;
+		return;
+	}
+	ulong max = i + 300;
+	for( ; i < max && i < lines().size(); ++i ) {
+		str line = lines()[i];
 		// Trim the trailing newline
 		qchar c;
 		while(( c = line[line.length () - 1] ) == '\n' || c == '\r' )
 			line.chop( 1 );
 		LDObject* obj = parseLine( line );
 		// Check for parse errors and warn about tthem
-		if( obj->getType () == LDObject::Gibberish )
+		if( obj->getType () == LDObject::Gibberish ) {
-		{
 			log( "Couldn't parse line #%1: %2", m_progress + 1, static_cast<LDGibberish*> (obj)->reason );
-			log( "- Line was: %1", line );
+			if( m_warningsPointer ) {
-			if( m_warningsPointer )
+				( *m_warningsPointer )++; }}
-				( *m_warningsPointer )++;
-		}
 		m_objs << obj;
-		m_progress++;
+		setProgress( i );
-		emit progressUpdate( m_progress );
+		if( concurrent() )
-		if( abortflag )
+			dlg->updateProgress( i );
-		{
+	}
-			// We were flagged for abortion, so abort.
-			for( LDObject* obj : m_objs )
+	if( i >= lines().size() - 1 ) {
-				delete obj;
+		emit workDone();
+		setDone( true ); }
-			m_objs.clear();
-			return;
+	if( !done() ) {
-		}
+		if( concurrent() )
-	}
+			QMetaObject::invokeMethod( this, "work", Qt::QueuedConnection, Q_ARG( ulong, i + 1 ));
+		else
-	emit workDone();
+			work( i + 1 );
-	m_done = true;
+	}
 }
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
 	g_aborted = false;
 	if( numWarnings )
 		*numWarnings = 0;
+	// Calculate the amount of lines
+	for( str line : *f )
+		lines << line;
+	f->rewind();
 	FileLoader* loader = new FileLoader;
-	loader->setFile( f );
 	loader->setWarningsPointer( numWarnings );
+	loader->setLines( lines );
-	// Calculate the amount of lines
+	loader->setConcurrent( g_loadingMainFile );
-	ulong numLines = 0;
+	loader->start();
-	for( str line : *f )
-		numLines++;
+	while( loader->done() == false )
+		qApp->processEvents();
-	f->rewind();
-	if (g_loadingMainFile)
-	{
-		// Show a progress dialog if we're loading the main file here and move
-		// the actual work to a separate thread as this can be a rather intensive
-		// operation and if we don't respond quickly enough, the program can be
-		// deemed inresponsive.. which is a bad thing.
-		// Init the thread and move the loader into it
-		QThread* loaderThread = new QThread;
-		QObject::connect( loaderThread, SIGNAL( started() ), loader, SLOT( work() ));
-		QObject::connect( loaderThread, SIGNAL( finished() ), loader, SLOT( deleteLater() ));
-		loader->moveToThread (loaderThread);
-		loaderThread->start ();
-		// Now create a progress prompt for the operation
-		OpenProgressDialog* dlg = new OpenProgressDialog (g_win);
-		dlg->setNumLines( numLines );
-		// Connect the loader in so we can show updates
-		QObject::connect( loader, SIGNAL( progressUpdate( int )), dlg, SLOT( updateProgress( int )));
-		QObject::connect( loader, SIGNAL( workDone() ), dlg, SLOT( accept() ));
-		// Show the prompt. If the user hits cancel, tell the loader to abort.
-		if( !dlg->exec() )
-		{
-			loader->abortflag = true;
-			g_aborted = true;
-		}
-	} else
-		loader->work();
 	// If we wanted the success value, supply that now
 	if( ok )
 		*ok = loader->done();
-	// If the loader was done, return the objects it generated
+	objs = loader->objs();
-	if( loader->done() )
-		objs = loader->objs();
 	return objs;
 }
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 	if( search )
 		f = openLDrawFile (path.toLower (), true);
 	else {
 		f = new File( path, File::Read );
-		if( !*f )
+		if( !*f ) {
-		{
 			delete f;
-			f = null;
+			return null; }}
-		}
-	}
 	if( !f )
 		return null;
 	LDOpenFile* oldLoad = g_curfile;
 }
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
-LDOpenFile* getFile( str fname )
+LDOpenFile* getFile( str filename )
 {
 	// Try find the file in the list of loaded files
-	LDOpenFile* load = findLoadedFile( fname );
+	LDOpenFile* load = findLoadedFile( filename );
 	// If it's not loaded, try open it
 	if( !load )
-		load = openDATFile( fname, true );
+		load = openDATFile( filename, true );
 	return load;
 }
 // =============================================================================

Mercurial > ldforge / file comparison

comparison: src/file.cpp

src/file.cpp