ldforge: comparison src/ldDocument.cc

-:577bc177a06f
+:2f1bd9112408
 		QString partsPath, primsPath;
 	} pathInfo;
 	void initPaths()
 	{
-		if (!tryConfigure (io_ldpath))
+		if (not tryConfigure (io_ldpath))
 		{
 			LDrawPathDialog dlg (false);
-			if (!dlg.exec())
+			if (not dlg.exec())
 				exit (0);
 			io_ldpath = dlg.filename();
 		}
 	}
 	bool tryConfigure (QString path)
 	{
 		QDir dir;
-		if (!dir.cd (path))
+		if (not dir.cd (path))
 		{
 			pathError = "Directory does not exist.";
 			return false;
 		}
 		// Try find an explicitly loaded file - if we can't find one,
 		// we need to create a new file to switch to.
 		for (LDDocument* file : g_loadedFiles)
 		{
-			if (!file->isImplicit())
+			if (not file->isImplicit())
 			{
 				LDDocument::setCurrent (file);
 				found = true;
 				break;
 			}
 		}
-		if (!found)
+		if (not found)
 			newFile();
 	}
 	if (this == g_logoedStud)
 		g_logoedStud = null;
 // =============================================================================
 //
 LDDocument* findDocument (QString name)
 {
 	for (LDDocument * file : g_loadedFiles)
-		if (!file->name().isEmpty() && file->name() == name)
+		if (not file->name().isEmpty() && file->name() == name)
 			return file;
 	return null;
 }
 					bogus = true;
 					break;
 				}
 			}
-			if (!bogus)
+			if (not bogus)
 				return partpath;
 		}
 	}
 	if (QFile::exists (relpath))
 		setDone (true);
 		return;
 	}
 	// Otherwise, continue, by recursing back.
-	if (!isDone())
+	if (not isDone())
 	{
 		// If we have a dialog to show progress output to, we cannot just call
 		// work() again immediately as the dialog needs some processor cycles as
 		// well. Thus, take a detour through the event loop by using the
 		// meta-object system.
 	if (numWarnings)
 		*numWarnings = 0;
 	// Read in the lines
-	while (fp->atEnd() == false)
+	while (not fp->atEnd())
 		lines << QString::fromUtf8 (fp->readLine());
 	LDFileLoader* loader = new LDFileLoader;
 	loader->setWarnings (numWarnings);
 	loader->setLines (lines);
 	// After start() returns, if the loader isn't done yet, it's delaying
 	// its next iteration through the event loop. We need to catch this here
 	// by telling the event loop to tick, which will tick the file loader again.
 	// We keep doing this until the file loader is ready.
-	while (loader->isDone() == false)
+	while (not loader->isDone())
 		qApp->processEvents();
 	// If we wanted the success value, supply that now
 	if (ok)
-		*ok = !loader->isAborted();
+		*ok = not loader->isAborted();
 	objs = loader->objects();
 	return objs;
 }
 	else
 	{
 		fp = new QFile (path);
 		fullpath = path;
-		if (!fp->open (QIODevice::ReadOnly))
+		if (not fp->open (QIODevice::ReadOnly))
 		{
 			delete fp;
 			return null;
 		}
 	}
-	if (!fp)
+	if (not fp)
 		return null;
 	LDDocument* load = new LDDocument;
 	load->setFullPath (fullpath);
 	load->setName (LDDocument::shortenName (load->fullPath()));
 	bool ok;
 	LDObjectList objs = loadFileContents (fp, &numWarnings, &ok);
 	fp->close();
 	fp->deleteLater();
-	if (!ok)
+	if (not ok)
 	{
 		g_loadedFiles.removeOne (load);
 		delete load;
 		return null;
 	}
 						return false;
 					setName (newpath);
 				}
-				if (!save())
+				if (not save())
 				{
 					message = format (tr ("Failed to save %1 (%2)\nDo you still want to close?"),
 						name(), strerror (errno));
 					if (msgbox::critical (g_win, tr ("Save Failure"), message,
 		}
 	}
 	// We cannot open this file if the document this would replace is not
 	// safe to close.
-	if (documentToReplace != null && documentToReplace->isSafeToClose() == false)
+	if (documentToReplace != null && not documentToReplace->isSafeToClose())
 	{
 		g_loadingMainFile = false;
 		return;
 	}
 	LDDocument* file = openDocument (path, false);
-	if (!file)
+	if (not file)
 	{
 		// Loading failed, thus drop down to a new file since we
 		// closed everything prior.
 		newFile();
-		if (!g_aborted)
+		if (not g_aborted)
 		{
 			// Tell the user loading failed.
 			setlocale (LC_ALL, "C");
 			critical (format (QObject::tr ("Failed to open %1: %2"), path, strerror (errno)));
 		}
 // =============================================================================
 //
 bool LDDocument::save (QString savepath)
 {
-	if (!savepath.length())
+	if (not savepath.length())
 		savepath = fullPath();
 	QFile f (savepath);
-	if (!f.open (QIODevice::WriteOnly))
+	if (not f.open (QIODevice::WriteOnly))
 		return false;
 	// If the second object in the list holds the file name, update that now.
 	// Only do this if the file is explicitly open.
 	LDObject* nameObject = getObject (1);
-	if (!isImplicit() && nameObject != null && nameObject->type() == LDObject::EComment)
+	if (not isImplicit() && nameObject != null && nameObject->type() == LDObject::EComment)
 	{
 		LDComment* nameComment = static_cast<LDComment*> (nameObject);
 		if (nameComment->text().left (6) == "Name: ")
 		{
 	for (int i = min; i <= max; ++i)
 	{
 		tokens[i].toDouble (&ok);
-		if (!ok && !scient.exactMatch (tokens[i]))
+		if (not ok && not scient.exactMatch (tokens[i]))
-			throw LDParseError (line, format ("Token #%1 was `%2`, expected a number (matched length: %3)", (i + 1), tokens[i], scient.matchedLength()));
+		{
+			throw LDParseError (line, format ("Token #%1 was `%2`, expected a number (matched length: %3)",
+				(i + 1), tokens[i], scient.matchedLength()));
+		}
 	}
 }
 // =============================================================================
 //
 		{
 			// Line was empty, or only consisted of whitespace
 			return new LDEmpty;
 		}
-		if (tokens[0].length() != 1 || tokens[0][0].isDigit() == false)
+		if (tokens[0].length() != 1 || not tokens[0][0].isDigit())
 			throw LDParseError (line, "Illogical line code");
 		int num = tokens[0][0].digitValue();
 		switch (num)
 				LDDocument* load = getDocument (tokens[14]);
 				g_loadingMainFile = tmp;
 				// If we cannot open the file, mark it an error. Note we cannot use LDParseError
 				// here because the error object needs the document reference.
-				if (!load)
+				if (not load)
 				{
 					LDError* obj = new LDError (line, format ("Could not open %1", tokens[14]));
 					obj->setFileReferenced (tokens[14]);
 					return obj;
 				}
 {
 	// Try find the file in the list of loaded files
 	LDDocument* doc = findDocument (filename);
 	// If it's not loaded, try open it
-	if (!doc)
+	if (not doc)
 		doc = openDocument (filename, true);
 	return doc;
 }
 // =============================================================================
 //
 void reloadAllSubfiles()
 {
-	if (!getCurrentDocument())
+	if (not getCurrentDocument())
 		return;
 	g_loadedFiles.clear();
 	g_loadedFiles << getCurrentDocument();
 	if (obj->type() == LDObject::EVertex)
 		m_vertices << obj;
 #ifdef DEBUG
-	if (!isImplicit())
+	if (not isImplicit())
 		dprint ("Added object #%1 (%2)\n", obj->id(), obj->typeName());
 #endif
 	obj->setDocument (this);
 	return getObjectCount() - 1;
 	history()->add (new AddHistory (pos, obj));
 	m_objects.insert (pos, obj);
 	obj->setDocument (this);
 #ifdef DEBUG
-	if (!isImplicit())
+	if (not isImplicit())
 		dprint ("Inserted object #%1 (%2) at %3\n", obj->id(), obj->typeName(), pos);
 #endif
 }
 // =============================================================================
 {
 	int idx = obj->lineNumber();
 	obj->unselect();
 	assert (m_objects[idx] == obj);
-	if (!history()->isIgnoring())
+	if (not history()->isIgnoring())
 		history()->add (new DelHistory (idx, obj));
 	m_objects.removeAt (idx);
 	obj->setDocument (null);
 }
 // =============================================================================
 //
 bool safeToCloseAll()
 {
 	for (LDDocument* f : g_loadedFiles)
-		if (!f->isSafeToClose())
+		if (not f->isSafeToClose())
 			return false;
 	return true;
 }
 void LDDocument::setObject (int idx, LDObject* obj)
 {
 	assert (idx >= 0 && idx < m_objects.size());
 	// Mark this change to history
-	if (!m_history->isIgnoring())
+	if (not m_history->isIgnoring())
 	{
 		QString oldcode = getObject (idx)->asText();
 		QString newcode = obj->asText();
 		*m_history << new EditHistory (idx, oldcode, newcode);
 	}
 // =============================================================================
 //
 QString LDDocument::getDisplayName()
 {
-	if (!name().isEmpty())
+	if (not name().isEmpty())
 		return name();
-	if (!defaultName().isEmpty())
+	if (not defaultName().isEmpty())
 		return "[" + defaultName() + "]";
 	return tr ("<anonymous>");
 }
 		m_cache.clear();
 		doCache = true;
 	}
 	// If we have this cached, just create a copy of that
-	if (deep && cache().isEmpty() == false)
+	if (deep && not cache().isEmpty())
 	{
 		for (LDObject* obj : cache())
 			objs << obj->createCopy();
 	}
 	else
 	{
-		if (!deep)
+		if (not deep)
 			doCache = false;
 		for (LDObject* obj : objects())
 		{
 			// Skip those without scemantic meaning
-			if (!obj->isScemantic())
+			if (not obj->isScemantic())
 				continue;
 			// Got another sub-file reference, inline it if we're deep-inlining. If not,
 			// just add it into the objects normally. Also, we only cache immediate
 			// subfiles and this is not one. Yay, recursion!
 int LDDocument::countExplicitFiles()
 {
 	int count = 0;
 	for (LDDocument* f : g_loadedFiles)
-		if (f->isImplicit() == false)
+	{
-			count++;
+		if (not f->isImplicit())
+			++count;
+	}
 	return count;
 }
 // =============================================================================
 // This little beauty closes the initial file that was open at first when opening
 // a new file over it.
 // =============================================================================
 void LDDocument::closeInitialFile()
 {
-	if (
+	if (countExplicitFiles() == 2 &&
-		countExplicitFiles() == 2 &&
 		g_loadedFiles[0]->name().isEmpty() &&
-		g_loadedFiles[1]->name().isEmpty() == false &&
+		not g_loadedFiles[1]->name().isEmpty() &&
-		!g_loadedFiles[0]->hasUnsavedChanges()
+		not g_loadedFiles[0]->hasUnsavedChanges())
-	)
+	{
 		delete g_loadedFiles[0];
+	}
 }
 // =============================================================================
 //
 void loadLogoedStuds()
 // =============================================================================
 //
 void LDDocument::removeFromSelection (LDObject* obj) // [protected]
 {
-	if (!obj->isSelected())
+	if (not obj->isSelected())
 		return;
 	assert (obj->document() == this);
 	m_sel.removeOne (obj);
 	obj->setSelected (false);

Mercurial > ldforge / file comparison

comparison: src/ldDocument.cc

src/ldDocument.cc