X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbufferlist.C;h=2ae3df66871419a7450d8f7a8e690c61e7c547fc;hb=9ee46b846e5e84ad40ceda4f4af94aeb86cd90a2;hp=f0b289eb92f8ac88aaefa1c427beddcec8c75f33;hpb=bae36d14f78a3cddbceb9ccc03f892da29627889;p=lyx.git

diff --git a/src/bufferlist.C b/src/bufferlist.C
index f0b289eb92..2ae3df6687 100644
--- a/src/bufferlist.C
+++ b/src/bufferlist.C
@@ -1,233 +1,205 @@
-/* This file is part of
- * ====================================================== 
- * 
- *           LyX, The Document Word Processor
+/**
+ * \file bufferlist.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2001 The LyX Team. 
+ * \author Lars Gullik Bjønnes
  *
- *           This file is Copyright 1996-2001
- *           Lars Gullik Bjønnes
- *
- * ====================================================== 
+ * Full author contact details are available in file CREDITS.
  */
 
 #include <config.h>
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
 #include "bufferlist.h"
-#include "lyx_main.h"
-#include "lastfiles.h"
+
+#include "author.h"
+#include "buffer.h"
+#include "bufferparams.h"
 #include "debug.h"
-#include "lyxrc.h"
-#include "lyxtext.h"
-#include "lyx_cb.h"
-#include "bufferview_funcs.h"
-#include "BufferView.h"
 #include "gettext.h"
-#include "LyXView.h"
-#include "vc-backend.h"
-#include "TextCache.h"
-#include "lyxtextclasslist.h"
+#include "lastfiles.h"
+#include "lyx_cb.h"
+#include "lyx_main.h"
+#include "output_latex.h"
+#include "paragraph.h"
+#include "ParagraphList_fwd.h"
 
 #include "frontends/Alert.h"
 
-#include "support/FileInfo.h"
 #include "support/filetools.h"
-#include "support/lyxmanip.h"
-#include "support/lyxfunctional.h"
-#include "support/LAssert.h"
+#include "support/package.h"
+
+#include <boost/bind.hpp>
 
-#include <cassert>
 #include <algorithm>
 #include <functional>
 
+using lyx::support::AddName;
+using lyx::support::bformat;
+using lyx::support::MakeAbsPath;
+using lyx::support::MakeDisplayPath;
+using lyx::support::OnlyFilename;
+using lyx::support::removeAutosaveFile;
+using lyx::support::package;
+using lyx::support::prefixIs;
 
-using std::vector;
-using std::find;
+using boost::bind;
+
+using std::auto_ptr;
 using std::endl;
+using std::equal_to;
+using std::find;
 using std::find_if;
 using std::for_each;
-using std::mem_fun;
+using std::string;
+using std::vector;
+using std::back_inserter;
+using std::transform;
+
 
-extern BufferView * current_view;
+BufferList::BufferList()
+{}
 
-//
-// Class BufferStorage
-//
 
-void BufferStorage::release(Buffer * buf)
+bool BufferList::empty() const
 {
-	lyx::Assert(buf);
-	Container::iterator it = find(container.begin(), container.end(), buf);
-	if (it != container.end()) {
-		// Make sure that we don't store a LyXText in
-		// the textcache that points to the buffer
-		// we just deleted.
-		Buffer * tmp = (*it);
-		container.erase(it);
-		textcache.removeAllWithBuffer(tmp);
-		delete tmp;
-	}
+	return bstore.empty();
 }
 
 
-Buffer * BufferStorage::newBuffer(string const & s, bool ronly)
+bool BufferList::quitWriteBuffer(Buffer * buf)
 {
-	Buffer * tmpbuf = new Buffer(s, ronly);
-	tmpbuf->params.useClassDefaults();
-	lyxerr[Debug::INFO] << "Assigning to buffer "
-			    << container.size() << endl;
-	container.push_back(tmpbuf);
-	return tmpbuf;
-}
-
+	BOOST_ASSERT(buf);
 
-//
-// Class BufferList
-//
+	string file;
+	if (buf->isUnnamed())
+		file = OnlyFilename(buf->fileName());
+	else
+		file = MakeDisplayPath(buf->fileName(), 30);
 
-BufferList::BufferList()
-	: state_(BufferList::OK)
-{}
+	string const text =
+		bformat(_("The document %1$s has unsaved changes.\n\n"
+			  "Do you want to save the document or discard the changes?"), file);
+	int const ret = Alert::prompt(_("Save changed document?"),
+		text, 0, 2, _("&Save"), _("&Discard"), _("&Cancel"));
 
+	if (ret == 0) {
+		// FIXME: WriteAs can be asynch !
+		// but not right now...maybe we should remove that
 
-bool BufferList::empty() const
-{
-	return bstore.empty();
-}
+		bool succeeded;
 
+		if (buf->isUnnamed())
+			succeeded = WriteAs(buf);
+		else
+			succeeded = MenuWrite(buf);
 
-bool BufferList::qwriteOne(Buffer * buf, string const & fname,
-			   string & unsaved_list)
-{
-	bool reask = true;
-	while (reask) {
-		switch (Alert::askConfirmation(_("Changes in document:"),
-				       fname,
-				       _("Save document?"))) {
-		case 1: // Yes
-			// FIXME: WriteAs can be asynch !
-			if (buf->isUnnamed())
-				reask = !WriteAs(current_view, buf);
-			else {
-				reask = !MenuWrite(current_view, buf);
-			}
-			break;
-		case 2: // No
-			// if we crash after this we could
-			// have no autosave file but I guess
-			// this is really inprobable (Jug)
-			if (buf->isUnnamed()) {
-				removeAutosaveFile(buf->fileName());
-			}
- 
-			unsaved_list += MakeDisplayPath(fname, 50) + "\n";
-			return true;
-		case 3: // Cancel
+		if (!succeeded)
 			return false;
-		}
+	} else if (ret == 1) {
+		// if we crash after this we could
+		// have no autosave file but I guess
+		// this is really inprobable (Jug)
+		if (buf->isUnnamed())
+			removeAutosaveFile(buf->fileName());
+
+	} else {
+		return false;
 	}
+
 	return true;
 }
 
- 
-bool BufferList::qwriteAll()
+
+bool BufferList::quitWriteAll()
 {
-	string unsaved;
 	BufferStorage::iterator it = bstore.begin();
 	BufferStorage::iterator end = bstore.end();
 	for (; it != end; ++it) {
-		if (!(*it)->isLyxClean()) {
-			string fname;
-			if ((*it)->isUnnamed())
-				fname = OnlyFilename((*it)->fileName());
-			else
-				fname = MakeDisplayPath((*it)->fileName(), 50);
-			if (!qwriteOne(*it, fname, unsaved)) // cancel the request!
-				return false;
-		}
-	}
- 
-	if (!unsaved.empty() && lyxrc.exit_confirmation) {
-		return Alert::askQuestion(_("Some documents were not saved:"),
-		                          unsaved, _("Exit anyway?"));
+		if ((*it)->isClean())
+			continue;
+
+		if (!quitWriteBuffer(*it))
+			return false;
 	}
 
 	return true;
 }
 
 
+void BufferList::release(Buffer * buf)
+{
+	BOOST_ASSERT(buf);
+	BufferStorage::iterator const it =
+		find(bstore.begin(), bstore.end(), buf);
+	if (it != bstore.end()) {
+		Buffer * tmp = (*it);
+		BOOST_ASSERT(tmp);
+		bstore.erase(it);
+		delete tmp;
+	}
+}
+
+
+Buffer * BufferList::newBuffer(string const & s, bool const ronly)
+{
+	auto_ptr<Buffer> tmpbuf(new Buffer(s, ronly));
+	tmpbuf->params().useClassDefaults();
+	lyxerr[Debug::INFO] << "Assigning to buffer "
+			    << bstore.size() << endl;
+	bstore.push_back(tmpbuf.get());
+	return tmpbuf.release();
+}
+
+
 void BufferList::closeAll()
 {
-	state_ = BufferList::CLOSING;
-	// Since we are closing we can just as well delete all
-	// in the textcache this will also speed the closing/quiting up a bit.
-	textcache.clear();
-	
 	while (!bstore.empty()) {
-		close(bstore.front());
+		close(bstore.front(), false);
 	}
-	state_ = BufferList::OK;
 }
 
 
-bool BufferList::close(Buffer * buf)
+bool BufferList::close(Buffer * buf, bool const ask)
 {
-	lyx::Assert(buf);
-	
-	// CHECK
-	// Trace back why we need to use buf->getUser here.
-	// Perhaps slight rewrite is in order? (Lgb)
-	
-        if (buf->getUser())
-		buf->getUser()->insetUnlock();
-	
-	if (buf->paragraph && !buf->isLyxClean() && !quitting) {
-		if (buf->getUser())
-			buf->getUser()->owner()->prohibitInput();
-		string fname;
-		if (buf->isUnnamed())
-			fname = OnlyFilename(buf->fileName());
-		else
-			fname = MakeDisplayPath(buf->fileName(), 50);
-		bool reask = true;
-		while (reask) {
-			switch (Alert::askConfirmation(_("Changes in document:"),
-					       fname,
-					       _("Save document?"))) {
-			case 1: // Yes
-				if (buf->isUnnamed())
-					reask = !WriteAs(current_view, buf);
-				else if (buf->save()) {
-					lastfiles->newFile(buf->fileName());
-					reask = false;
-				} else {
-					if (buf->getUser())
-						buf->getUser()->owner()->allowInput();
-					return false;
-				}
-				break;
-			case 2:
-				if (buf->isUnnamed()) {
-					removeAutosaveFile(buf->fileName());
-				}
-				reask = false;
-				break;
-			case 3: // Cancel
-				if (buf->getUser())
-					buf->getUser()->owner()->allowInput();
+	BOOST_ASSERT(buf);
+
+	// FIXME: is the quitting check still necessary ?
+	if (!ask || buf->isClean() || quitting || buf->paragraphs().empty()) {
+		release(buf);
+		return true;
+	}
+
+	string fname;
+	if (buf->isUnnamed())
+		fname = OnlyFilename(buf->fileName());
+	else
+		fname = MakeDisplayPath(buf->fileName(), 30);
+
+	string const text =
+		bformat(_("The document %1$s has unsaved changes.\n\n"
+			  "Do you want to save the document or discard the changes?"), fname);
+	int const ret = Alert::prompt(_("Save changed document?"),
+		text, 0, 2, _("&Save"), _("&Discard"), _("&Cancel"));
+
+	if (ret == 0) {
+		if (buf->isUnnamed()) {
+			if (!WriteAs(buf))
 				return false;
-			}
+		} else if (buf->save()) {
+			LyX::ref().lastfiles().newFile(buf->fileName());
+		} else {
+			return false;
 		}
-		if (buf->getUser())
-			buf->getUser()->owner()->allowInput();
+	} else if (ret == 2) {
+		return false;
+	}
+
+	if (buf->isUnnamed()) {
+		removeAutosaveFile(buf->fileName());
 	}
 
-	bstore.release(buf);
+	release(buf);
 	return true;
 }
 
@@ -235,8 +207,9 @@ bool BufferList::close(Buffer * buf)
 vector<string> const BufferList::getFileNames() const
 {
 	vector<string> nvec;
-	std::copy(bstore.begin(), bstore.end(),
-		  lyx::back_inserter_fun(nvec, &Buffer::fileName));
+	transform(bstore.begin(), bstore.end(),
+		  back_inserter(nvec),
+		  boost::bind(&Buffer::fileName, _1));
 	return nvec;
 }
 
@@ -249,7 +222,7 @@ Buffer * BufferList::first()
 }
 
 
-Buffer * BufferList::getBuffer(unsigned int choice)
+Buffer * BufferList::getBuffer(unsigned int const choice)
 {
 	if (choice >= bstore.size())
 		return 0;
@@ -257,24 +230,41 @@ Buffer * BufferList::getBuffer(unsigned int choice)
 }
 
 
-int BufferList::unlockInset(UpdatableInset * inset)
+Buffer * BufferList::next(Buffer const * buf) const
 {
-	lyx::Assert(inset);
-	
-	BufferStorage::iterator it = bstore.begin();
-	BufferStorage::iterator end = bstore.end();
-	for (; it != end; ++it) {
-		if ((*it)->getUser()
-		    && (*it)->getUser()->theLockingInset() == inset) {
-			(*it)->getUser()->insetUnlock();
-			return 0;
-		}
-	}
-	return 1;
+	BOOST_ASSERT(buf);
+
+	if (bstore.empty())
+		return 0;
+	BufferStorage::const_iterator it = find(bstore.begin(),
+						bstore.end(), buf);
+	BOOST_ASSERT(it != bstore.end());
+	++it;
+	if (it == bstore.end())
+		return bstore.front();
+	else
+		return *it;
 }
 
 
-void BufferList::updateIncludedTeXfiles(string const & mastertmpdir)
+Buffer * BufferList::previous(Buffer const * buf) const
+{
+	BOOST_ASSERT(buf);
+
+	if (bstore.empty())
+		return 0;
+	BufferStorage::const_iterator it = find(bstore.begin(),
+						bstore.end(), buf);
+	BOOST_ASSERT(it != bstore.end());
+	if (it == bstore.begin())
+		return bstore.back();
+	else
+		return *(it - 1);
+}
+
+
+void BufferList::updateIncludedTeXfiles(string const & mastertmpdir,
+					OutputParams const & runparams)
 {
 	BufferStorage::iterator it = bstore.begin();
 	BufferStorage::iterator end = bstore.end();
@@ -284,7 +274,7 @@ void BufferList::updateIncludedTeXfiles(string const & mastertmpdir)
 			writefile += '/';
 			writefile += (*it)->getLatexName();
 			(*it)->makeLaTeXFile(writefile, mastertmpdir,
-					     false, true);
+					     runparams, false);
 			(*it)->markDepClean(mastertmpdir);
 		}
 	}
@@ -294,61 +284,60 @@ void BufferList::updateIncludedTeXfiles(string const & mastertmpdir)
 void BufferList::emergencyWriteAll()
 {
 	for_each(bstore.begin(), bstore.end(),
-		 lyx::class_fun(*this, &BufferList::emergencyWrite));
+		 bind(&BufferList::emergencyWrite, this, _1));
 }
 
 
-void BufferList::emergencyWrite(Buffer * buf) 
+void BufferList::emergencyWrite(Buffer * buf)
 {
-	// assert(buf) // this is not good since C assert takes an int
-	               // and a pointer is a long (JMarc)
-	assert(buf != 0); // use c assert to avoid a loop
+	// Use ::assert to avoid a loop, BOOST_ASSERT ends up calling ::assert
+	// compare with 0 to avoid pointer/interger comparison
+	assert(buf != 0);
 
-	
 	// No need to save if the buffer has not changed.
-	if (buf->isLyxClean())
+	if (buf->isClean())
 		return;
-	
-	lyxerr << fmt(_("lyx: Attempting to save document %s as..."),
-		      buf->isUnnamed() ? OnlyFilename(buf->fileName()).c_str()
-		      : buf->fileName().c_str()) << endl;
-	
-	// We try to save three places:
 
+	string const doc = buf->isUnnamed()
+		? OnlyFilename(buf->fileName()) : buf->fileName();
+
+	lyxerr << bformat(_("LyX: Attempting to save document %1$s"), doc) << endl;
+
+	// We try to save three places:
 	// 1) Same place as document. Unless it is an unnamed doc.
 	if (!buf->isUnnamed()) {
 		string s = buf->fileName();
 		s += ".emergency";
 		lyxerr << "  " << s << endl;
-		if (buf->writeFile(s, true)) {
-			buf->markLyxClean();
+		if (buf->writeFile(s)) {
+			buf->markClean();
 			lyxerr << _("  Save seems successful. Phew.") << endl;
 			return;
 		} else {
 			lyxerr << _("  Save failed! Trying...") << endl;
 		}
 	}
-	
+
 	// 2) In HOME directory.
-	string s = AddName(GetEnvPath("HOME"), buf->fileName());
+	string s = AddName(package().home_dir(), buf->fileName());
 	s += ".emergency";
-	lyxerr << " " << s << endl;
-	if (buf->writeFile(s, true)) {
-		buf->markLyxClean();
+	lyxerr << ' ' << s << endl;
+	if (buf->writeFile(s)) {
+		buf->markClean();
 		lyxerr << _("  Save seems successful. Phew.") << endl;
 		return;
 	}
-	
+
 	lyxerr << _("  Save failed! Trying...") << endl;
-	
+
 	// 3) In "/tmp" directory.
 	// MakeAbsPath to prepend the current
 	// drive letter on OS/2
 	s = AddName(MakeAbsPath("/tmp/"), buf->fileName());
 	s += ".emergency";
-	lyxerr << " " << s << endl;
-	if (buf->writeFile(s, true)) {
-		buf->markLyxClean();
+	lyxerr << ' ' << s << endl;
+	if (buf->writeFile(s)) {
+		buf->markClean();
 		lyxerr << _("  Save seems successful. Phew.") << endl;
 		return;
 	}
@@ -356,94 +345,19 @@ void BufferList::emergencyWrite(Buffer * buf)
 }
 
 
-
-Buffer * BufferList::readFile(string const & s, bool ronly)
-{
-	string ts(s);
-	string e = OnlyPath(s);
-	string a = e;
-	// File information about normal file
-	FileInfo fileInfo2(s);
-
-	if (!fileInfo2.exist()) {
-		Alert::alert(_("Error!"), _("Cannot open file"), 
-			MakeDisplayPath(s));
-		return 0;
-	}
- 
-	Buffer * b = bstore.newBuffer(s, ronly);
-
-	// Check if emergency save file exists and is newer.
-	e += OnlyFilename(s) + ".emergency";
-	FileInfo fileInfoE(e);
-
-	bool use_emergency = false;
-
-	if (fileInfoE.exist() && fileInfo2.exist()) {
-		if (fileInfoE.getModificationTime()
-		    > fileInfo2.getModificationTime()) {
-			if (Alert::askQuestion(_("An emergency save of this document exists!"),
-					MakeDisplayPath(s, 50),
-					_("Try to load that instead?"))) {
-				ts = e;
-				// the file is not saved if we load the
-				// emergency file.
-				b->markDirty();
-				use_emergency = true;
-			} else {
-				// Here, we should delete the emergency save
-				lyx::unlink(e);
-			}
-		}
-	}
-
-	if (!use_emergency) {
-		// Now check if autosave file is newer.
-		a += '#';
-		a += OnlyFilename(s);
-		a += '#';
-		FileInfo fileInfoA(a);
-		if (fileInfoA.exist() && fileInfo2.exist()) {
-			if (fileInfoA.getModificationTime()
-			    > fileInfo2.getModificationTime()) {
-				if (Alert::askQuestion(_("Autosave file is newer."),
-						MakeDisplayPath(s, 50),
-						_("Load that one instead?"))) {
-					ts = a;
-					// the file is not saved if we load the
-					// autosave file.
-					b->markDirty();
-				} else {
-					// Here, we should delete the autosave
-					lyx::unlink(a);
-				}
-			}
-		}
-	}
-	// not sure if this is the correct place to begin LyXLex
-	LyXLex lex(0, 0);
-	lex.setFile(ts);
-	if (b->readFile(lex))
-		return b;
-	else {
-		bstore.release(b);
-		return 0;
-	}
-}
-
-
 bool BufferList::exists(string const & s) const
 {
 	return find_if(bstore.begin(), bstore.end(),
-		       lyx::compare_memfun(&Buffer::fileName, s))
+		       bind(equal_to<string>(),
+			    bind(&Buffer::fileName, _1),
+			    s))
 		!= bstore.end();
 }
 
 
 bool BufferList::isLoaded(Buffer const * b) const
 {
-	lyx::Assert(b);
-	
+	BOOST_ASSERT(b);
 	BufferStorage::const_iterator cit =
 		find(bstore.begin(), bstore.end(), b);
 	return cit != bstore.end();
@@ -454,114 +368,30 @@ Buffer * BufferList::getBuffer(string const & s)
 {
 	BufferStorage::iterator it =
 		find_if(bstore.begin(), bstore.end(),
-			lyx::compare_memfun(&Buffer::fileName, s));
+			bind(equal_to<string>(),
+			     bind(&Buffer::fileName, _1),
+			     s));
+
 	return it != bstore.end() ? (*it) : 0;
 }
 
 
-Buffer * BufferList::newFile(string const & name, string tname, bool isNamed)
+Buffer * BufferList::getBufferFromTmp(string const & s)
 {
-	// get a free buffer
-	Buffer * b = bstore.newBuffer(name);
-
-	// use defaults.lyx as a default template if it exists.
-	if (tname.empty()) {
-		tname = LibFileSearch("templates", "defaults.lyx");
-	}
-	if (!tname.empty()) {
-		bool templateok = false;
-		LyXLex lex(0, 0);
-		lex.setFile(tname);
-		if (lex.isOK()) {
-			if (b->readFile(lex)) {
-				templateok = true;
-			}
-		}
-		if (!templateok) {
-			Alert::alert(_("Error!"), _("Unable to open template"),
-				   MakeDisplayPath(tname));
-			// no template, start with empty buffer
-			b->paragraph = new Paragraph;
-			b->paragraph->layout(textclasslist[b->params.textclass].defaultLayoutName());
-		}
-	} else {  // start with empty buffer
-		b->paragraph = new Paragraph;
-			b->paragraph->layout(textclasslist[b->params.textclass].defaultLayoutName());
-	}
-
-	if (!lyxrc.new_ask_filename && !isNamed) {
-		b->setUnnamed();
-		b->setFileName(name);
-	}
-
-	b->setReadonly(false);
-	
-	return b;
+	BufferStorage::iterator it = bstore.begin();
+	BufferStorage::iterator end = bstore.end();
+	for (; it < end; ++it)
+		if (prefixIs(s, (*it)->temppath()))
+			return *it;
+	return 0;
 }
 
 
-Buffer * BufferList::loadLyXFile(string const & filename, bool tolastfiles)
+void BufferList::setCurrentAuthor(string const & name, string const & email)
 {
-	// get absolute path of file and add ".lyx" to the filename if
-	// necessary
-	string s = FileSearch(string(), filename, "lyx");
-	if (s.empty()) {
-		s = filename;
-	}
-
-	// file already open?
-	if (exists(s)) {
-		if (Alert::askQuestion(_("Document is already open:"), 
-				MakeDisplayPath(s, 50),
-				_("Do you want to reload that document?"))) {
-			// Reload is accomplished by closing and then loading
-			if (!close(getBuffer(s))) {
-				return 0;
-			}
-			// Fall through to new load. (Asger)
-		} else {
-			// Here, we pretend that we just loaded the 
-			// open document
-			return getBuffer(s);
-		}
-	}
-	Buffer * b = 0;
-	bool ro = false;
-	switch (IsFileWriteable(s)) {
-	case 0:
-		ro = true;
-		// Fall through
-	case 1:
-		b = readFile(s, ro);
-		if (b) {
-			b->lyxvc.file_found_hook(s);
-		}
-		break; //fine- it's r/w
-	case -1:
-		// Here we probably should run
-		if (LyXVC::file_not_found_hook(s)) {
-			// Ask if the file should be checked out for
-			// viewing/editing, if so: load it.
-		        if (Alert::askQuestion(_("Do you want to retrieve file under version control?"))) {
-				// How can we know _how_ to do the checkout?
-				// With the current VC support it has to be,
-				// a RCS file since CVS do not have special ,v files.
-				RCS::retrieve(s);
-				return loadLyXFile(filename, tolastfiles);
-			}
-		}
-		if (Alert::askQuestion(_("Cannot open specified file:"), 
-				MakeDisplayPath(s, 50),
-				_("Create new document with this name?")))
-			{
-				// Find a free buffer
-				b = newFile(s, string(), true);
-			}
-		break;
+	BufferStorage::iterator it = bstore.begin();
+	BufferStorage::iterator end = bstore.end();
+	for (; it != end; ++it) {
+		(*it)->params().authors().record(0, Author(name, email));
 	}
-
-	if (b && tolastfiles)
-		lastfiles->newFile(b->fileName());
-
-	return b;
 }