anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-22 21:21:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

bufferlist cleanup

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@6163 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
John Levon 2003-02-15 19:21:11 +00:00
parent cff1b05078
commit 9fc9bd98f6
5 changed files with 66 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BufferView.C
View File

@ -787,7 +787,7 @@ int BufferView::unlockInset(UpdatableInset * inset)
finishUndo();
return 0;
}
return bufferlist.unlockInset(inset);
return 1;
}

4
src/BufferView_pimpl.C
View File

@ -170,7 +170,9 @@ void BufferView::Pimpl::buffer(Buffer * b)
// set current buffer
buffer_ = b;
if (bufferlist.getState() == BufferList::CLOSING) return;
// if we're quitting lyx, don't bother updating stuff
if (quitting)
return;
// if we are closing the buffer, use the first buffer as current
if (!buffer_) {

9
src/ChangeLog
View File

@ -1,3 +1,12 @@
2003-02-15 John Levon <levon@movementarian.org>
* BufferView.C:
* BufferView_pimpl.C:
* bufferlist.h:
* bufferlist.C: remove pointless BufferStorage bloat. Remove
inset code that had no actual effect. Remove unneeded status
code.
2003-02-14 Jean-Marc Lasgouttes <lasgouttes@freesurf.fr>
* buffer.C (makeLaTeXFile): fix counting of number of line feeds

96
src/bufferlist.C
View File

@ -54,43 +54,8 @@ using std::mem_fun;
extern BufferView * current_view;
//
// Class BufferStorage
//
void BufferStorage::release(Buffer * buf)
{
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;
}
}
Buffer * BufferStorage::newBuffer(string const & s, bool ronly)
{
Buffer * tmpbuf = new Buffer(s, ronly);
tmpbuf->params.useClassDefaults();
lyxerr[Debug::INFO] << "Assigning to buffer "
<< container.size() << endl;
container.push_back(tmpbuf);
return tmpbuf;
}
//
// Class BufferList
//
BufferList::BufferList()
: state_(BufferList::OK)
{}
@ -155,9 +120,35 @@ bool BufferList::qwriteAll()
}
void BufferList::release(Buffer * buf)
{
lyx::Assert(buf);
BufferStorage::iterator it = find(bstore.begin(), bstore.end(), buf);
if (it != bstore.end()) {
// Make sure that we don't store a LyXText in
// the textcache that points to the buffer
// we just deleted.
Buffer * tmp = (*it);
bstore.erase(it);
textcache.removeAllWithBuffer(tmp);
delete tmp;
}
}
Buffer * BufferList::newBuffer(string const & s, bool ronly)
{
Buffer * tmpbuf = new Buffer(s, ronly);
tmpbuf->params.useClassDefaults();
lyxerr[Debug::INFO] << "Assigning to buffer "
<< bstore.size() << endl;
bstore.push_back(tmpbuf);
return tmpbuf;
}
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();
@ -165,7 +156,6 @@ void BufferList::closeAll()
while (!bstore.empty()) {
close(bstore.front());
}
state_ = BufferList::OK;
}
@ -173,13 +163,6 @@ bool BufferList::close(Buffer * buf)
{
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->paragraphs.empty() && !buf->isClean() && !quitting) {
string fname;
if (buf->isUnnamed())
@ -213,7 +196,7 @@ bool BufferList::close(Buffer * buf)
}
}
bstore.release(buf);
release(buf);
return true;
}
@ -243,23 +226,6 @@ Buffer * BufferList::getBuffer(unsigned int choice)
}
int BufferList::unlockInset(UpdatableInset * inset)
{
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;
}
void BufferList::updateIncludedTeXfiles(string const & mastertmpdir)
{
BufferStorage::iterator it = bstore.begin();
@ -363,7 +329,7 @@ Buffer * BufferList::readFile(string const & s, bool ronly)
return 0;
}
Buffer * b = bstore.newBuffer(s, ronly);
Buffer * b = newBuffer(s, ronly);
// Check if emergency save file exists and is newer.
e += OnlyFilename(s) + ".emergency";
@ -418,7 +384,7 @@ Buffer * BufferList::readFile(string const & s, bool ronly)
if (b->readFile(lex, ts))
return b;
else {
bstore.release(b);
release(b);
return 0;
}
}
@ -454,7 +420,7 @@ Buffer * BufferList::getBuffer(string const & s)
Buffer * BufferList::newFile(string const & name, string tname, bool isNamed)
{
// get a free buffer
Buffer * b = bstore.newBuffer(name);
Buffer * b = newBuffer(name);
// use defaults.lyx as a default template if it exists.
if (tname.empty()) {

119
src/bufferlist.h
View File

@ -16,86 +16,15 @@
#include <vector>
class Buffer;
class UpdatableInset;
/** A class to hold all the buffers in a structure
The point of this class is to hide from bufferlist what kind
of structure the buffers are stored in. Should be no concern for
bufferlist if the buffers is in a array or in a linked list.
This class should ideally be enclosed inside class BufferList, but that
gave me an "internal gcc error".
*/
class BufferStorage : boost::noncopyable {
public:
///
typedef std::vector<Buffer *> Container;
///
typedef Container::iterator iterator;
///
typedef Container::const_iterator const_iterator;
///
typedef Container::size_type size_type;
/**
Is the container empty or not.
\return True if the container is empty, False otherwise.
*/
bool empty() const { return container.empty(); }
/**
Releases the passed buffer from the storage and deletes
all resources.
\param buf The buffer to release.
*/
void release(Buffer * buf);
/**
\param s The name of the file to base the buffer on.
\param ronly If the buffer should be created read only of not.
\return The newly created buffer.
*/
Buffer * newBuffer(string const & s, bool ronly = false);
///
Container::iterator begin() { return container.begin(); }
///
Container::iterator end() { return container.end(); }
///
Container::const_iterator begin() const { return container.begin(); }
///
Container::const_iterator end() const { return container.end(); }
///
Buffer * front() { return container.front(); }
///
Buffer * operator[](int c) { return container[c]; }
/**
What is the size of the container.
\return The size of the container.
*/
size_type size() const { return container.size(); }
private:
///
Container container;
};
/**
The class holds all all open buffers, and handles construction
and deletions of new ones.
* The class holds all all open buffers, and handles construction
* and deletions of new ones.
*/
class BufferList : boost::noncopyable {
public:
///
BufferList();
/// state info
enum list_state {
///
OK,
///
CLOSING
};
/// returns the state of the bufferlist
list_state getState() const { return state_; }
/**
Loads a LyX file or...
@ -107,19 +36,19 @@ public:
Buffer * loadLyXFile(string const & filename,
bool tolastfiles = true);
///
bool empty() const;
///
/// write all buffers, asking the user
bool qwriteAll();
/// create a new buffer
Buffer * newBuffer(string const & s, bool ronly = false);
/// delete a buffer
void release(Buffer * b);
/// Close all open buffers.
void closeAll();
/**
Read a file into a buffer readonly or not.
\return
*/
/// read the given file
Buffer * readFile(string const &, bool ro);
/// Make a new file (buffer) using a template
@ -127,23 +56,19 @@ public:
/// returns a vector with all the buffers filenames
std::vector<string> const getFileNames() const;
///
int unlockInset(UpdatableInset *);
///
/// FIXME
void updateIncludedTeXfiles(string const &);
///
/// emergency save for all buffers
void emergencyWriteAll();
/**
Close buffer.
\param buf the buffer that should be closed
\return #false# if operation was canceled
*/
/// close buffer. Returns false if cancelled by user
bool close(Buffer * buf);
///
/// return true if no buffers loaded
bool empty() const;
/// return head of buffer list if any
Buffer * first();
/// returns true if the buffer exists already
@ -165,13 +90,13 @@ private:
bool qwriteOne(Buffer * buf, string const & fname,
string & unsaved_list);
///
typedef std::vector<Buffer *> BufferStorage;
/// storage of all buffers
BufferStorage bstore;
///
list_state state_;
///
/// save emergency file for the given buffer
void emergencyWrite(Buffer * buf);
};
#endif
#endif // BUFFERLIST_H