#include "insets/insettext.h"
#include "frontends/Alert.h"
-#include "frontends/Application.h"
#include "frontends/FileDialog.h"
-#include "frontends/FontLoader.h"
#include "frontends/FontMetrics.h"
#include "graphics/Previews.h"
#include <vector>
-using lyx::docstring;
-using lyx::pos_type;
+namespace lyx {
-using lyx::support::addPath;
-using lyx::support::bformat;
-using lyx::support::FileFilterList;
-using lyx::support::fileSearch;
-using lyx::support::isDirWriteable;
-using lyx::support::makeDisplayPath;
-using lyx::support::makeAbsPath;
-using lyx::support::package;
+using support::addPath;
+using support::bformat;
+using support::FileFilterList;
+using support::fileSearch;
+using support::isDirWriteable;
+using support::makeDisplayPath;
+using support::makeAbsPath;
+using support::package;
using std::distance;
using std::endl;
using std::istringstream;
-using std::find;
using std::make_pair;
using std::min;
using std::max;
using std::string;
using std::vector;
-namespace Alert = lyx::frontend::Alert;
-
+namespace Alert = frontend::Alert;
namespace {
BufferView::BufferView()
- : buffer_(0), wh_(0),
+ : width_(0), height_(0), buffer_(0), wh_(0),
cursor_(*this),
multiparsel_cache_(false), anchor_ref_(0), offset_ref_(0),
intl_(new Intl)
saved_positions.resize(saved_positions_num);
// load saved bookmarks
- lyx::Session::BookmarkList & bmList = LyX::ref().session().loadBookmarks();
- for (lyx::Session::BookmarkList::iterator bm = bmList.begin();
+ BookmarksSection::BookmarkList & bmList = LyX::ref().session().bookmarks().load();
+ for (BookmarksSection::BookmarkList::iterator bm = bmList.begin();
bm != bmList.end(); ++bm)
if (bm->get<0>() < saved_positions_num)
saved_positions[bm->get<0>()] = Position( bm->get<1>(), bm->get<2>(), bm->get<3>() );
buffer_->saveCursor(cursor_.selectionBegin(),
cursor_.selectionEnd());
// current buffer is going to be switched-off, save cursor pos
- LyX::ref().session().saveFilePosition(buffer_->fileName(),
+ LyX::ref().session().lastFilePos().save(buffer_->fileName(),
boost::tie(cursor_.pit(), cursor_.pos()) );
}
lyxerr[Debug::INFO] << BOOST_CURRENT_FUNCTION
<< " No Buffer!" << endl;
// We are closing the buffer, use the first buffer as current
- buffer_ = theApp->bufferList().first();
+ buffer_ = theBufferList().first();
} else {
// Set current buffer
buffer_ = b;
update();
- if (buffer_ && lyx::graphics::Previews::status() != LyXRC::PREVIEW_OFF)
- lyx::graphics::Previews::get().generateBufferPreviews(*buffer_);
+ if (buffer_ && graphics::Previews::status() != LyXRC::PREVIEW_OFF)
+ graphics::Previews::get().generateBufferPreviews(*buffer_);
}
s = filename;
// File already open?
- if (theApp->bufferList().exists(s)) {
+ if (theBufferList().exists(s)) {
docstring const file = makeDisplayPath(s, 20);
docstring text = bformat(_("The document %1$s is already "
"loaded.\n\nDo you want to revert "
text, 0, 1, _("&Revert"), _("&Switch to document"));
if (ret != 0) {
- setBuffer(theApp->bufferList().getBuffer(s));
+ setBuffer(theBufferList().getBuffer(s));
return true;
}
// FIXME: should be LFUN_REVERT
- if (!theApp->bufferList().close(theApp->bufferList().getBuffer(s), false))
+ if (!theBufferList().close(theBufferList().getBuffer(s), false))
return false;
// Fall through to new load. (Asger)
+ buffer_ = 0;
}
Buffer * b = 0;
if (found) {
- b = theApp->bufferList().newBuffer(s);
- if (!::loadLyXFile(b, s)) {
- theApp->bufferList().release(b);
+ b = theBufferList().newBuffer(s);
+ if (!lyx::loadLyXFile(b, s)) {
+ theBufferList().release(b);
return false;
}
} else {
docstring text = bformat(_("The document %1$s does not yet "
"exist.\n\nDo you want to create "
- "a new document?"), lyx::from_utf8(s));
+ "a new document?"), from_utf8(s));
int const ret = Alert::prompt(_("Create new document?"),
text, 0, 1, _("&Create"), _("Cancel"));
// scroll to the position when the file was last closed
if (lyxrc.use_lastfilepos) {
- lyx::pit_type pit;
- lyx::pos_type pos;
- boost::tie(pit, pos) = LyX::ref().session().loadFilePosition(s);
+ pit_type pit;
+ pos_type pos;
+ boost::tie(pit, pos) = LyX::ref().session().lastFilePos().load(s);
// I am not sure how to separate the following part to a function
// so I will leave this to Lars.
//
}
if (tolastfiles)
- LyX::ref().session().addLastFile(b->fileName());
+ LyX::ref().session().lastFiles().add(b->fileName());
return true;
}
void BufferView::reload()
{
string const fn = buffer_->fileName();
- if (theApp->bufferList().close(buffer_, false))
+ if (theBufferList().close(buffer_, false))
loadLyXFile(fn);
}
bool BufferView::fitCursor()
{
if (bv_funcs::status(this, cursor_) == bv_funcs::CUR_INSIDE) {
- lyx::frontend::FontMetrics const & fm
- = theApp->fontLoader().metrics(cursor_.getFont());
+ frontend::FontMetrics const & fm =
+ theFontMetrics(cursor_.getFont());
int const asc = fm.maxAscent();
int const des = fm.maxDescent();
- Point const p = bv_funcs::getPos(cursor_, cursor_.boundary());
+ Point const p = bv_funcs::getPos(*this, cursor_, cursor_.boundary());
if (p.y_ - asc >= 0 && p.y_ + des < height_)
return false;
}
if (!buffer_)
return false;
+ lyxerr[Debug::WORKAREA] << "BufferView::update" << std::endl;
+
// Update macro store
buffer_->buildMacros();
// Look at paragraph heights on-screen
int sumh = 0;
int nh = 0;
- for (lyx::pit_type pit = anchor_ref_; pit <= parsize; ++pit) {
+ for (pit_type pit = anchor_ref_; pit <= parsize; ++pit) {
if (sumh > height_)
break;
int const h2 = t.getPar(pit).height();
sumh += h2;
nh++;
}
+
+ BOOST_ASSERT(nh);
int const hav = sumh / nh;
// More realistic average paragraph height
if (hav > wh_)
wh_ = hav;
+ BOOST_ASSERT(h);
scrollbarParameters_.height = (parsize + 1) * wh_;
scrollbarParameters_.position = anchor_ref_ * wh_ + int(offset_ref_ * wh_ / float(h));
scrollbarParameters_.lineScrollHeight = int(wh_ * defaultRowHeight() / float(h));
cur.clearSelection();
break;
case bv_funcs::CUR_INSIDE:
- int const y = bv_funcs::getPos(cur, cur.boundary()).y_;
+ int const y = bv_funcs::getPos(*this, cur, cur.boundary()).y_;
int const newy = min(last, max(y, first));
if (y != newy) {
cur.reset(buffer_->inset());
}
-Change const BufferView::getCurrentChange()
+Change const BufferView::getCurrentChange() const
{
if (!cursor_.selection())
return Change(Change::UNCHANGED);
if (fname != buffer_->fileName()) {
Buffer * b = 0;
- if (theApp->bufferList().exists(fname))
- b = theApp->bufferList().getBuffer(fname);
+ if (theBufferList().exists(fname))
+ b = theBufferList().getBuffer(fname);
else {
- b = theApp->bufferList().newBuffer(fname);
+ b = theBufferList().newBuffer(fname);
// Don't ask, just load it
- ::loadLyXFile(b, fname);
+ lyx::loadLyXFile(b, fname);
}
if (b)
setBuffer(b);
// par_id and pit.
for (unsigned int i=1; i < saved_positions_num; ++i) {
if ( isSavedPosition(i) )
- LyX::ref().session().saveBookmark( boost::tie(
+ LyX::ref().session().bookmarks().save( boost::tie(
i,
saved_positions[i].filename,
saved_positions[i].par_id,
void BufferView::center()
{
CursorSlice & bot = cursor_.bottom();
- lyx::pit_type const pit = bot.pit();
+ pit_type const pit = bot.pit();
bot.text()->redoParagraph(pit);
Paragraph const & par = bot.text()->paragraphs()[pit];
anchor_ref_ = pit;
- offset_ref_ = bv_funcs::coordOffset(cursor_, cursor_.boundary()).y_
+ offset_ref_ = bv_funcs::coordOffset(*this, cursor_, cursor_.boundary()).y_
+ par.ascent() - height_ / 2;
}
}
case LFUN_BOOKMARK_GOTO:
- flag.enabled(isSavedPosition(convert<unsigned int>(lyx::to_utf8(cmd.argument()))));
+ flag.enabled(isSavedPosition(convert<unsigned int>(to_utf8(cmd.argument()))));
break;
case LFUN_CHANGES_TRACK:
// Make sure that the cached BufferView is correct.
lyxerr[Debug::ACTION] << BOOST_CURRENT_FUNCTION
<< " action[" << cmd.action << ']'
- << " arg[" << lyx::to_utf8(cmd.argument()) << ']'
+ << " arg[" << to_utf8(cmd.argument()) << ']'
<< " x[" << cmd.x << ']'
<< " y[" << cmd.y << ']'
<< " button[" << cmd.button() << ']'
case LFUN_FILE_INSERT:
// FIXME: We don't know the encoding of filenames
- menuInsertLyXFile(lyx::to_utf8(cmd.argument()));
+ menuInsertLyXFile(to_utf8(cmd.argument()));
break;
case LFUN_FILE_INSERT_ASCII_PARA:
// FIXME: We don't know the encoding of filenames
- insertAsciiFile(this, lyx::to_utf8(cmd.argument()), true);
+ insertAsciiFile(this, to_utf8(cmd.argument()), true);
break;
case LFUN_FILE_INSERT_ASCII:
// FIXME: We don't know the encoding of filenames
- insertAsciiFile(this, lyx::to_utf8(cmd.argument()), false);
+ insertAsciiFile(this, to_utf8(cmd.argument()), false);
break;
case LFUN_FONT_STATE:
- cur.message(lyx::from_utf8(cur.currentState()));
+ cur.message(from_utf8(cur.currentState()));
break;
case LFUN_BOOKMARK_SAVE:
- savePosition(convert<unsigned int>(lyx::to_utf8(cmd.argument())));
+ savePosition(convert<unsigned int>(to_utf8(cmd.argument())));
break;
case LFUN_BOOKMARK_GOTO:
- restorePosition(convert<unsigned int>(lyx::to_utf8(cmd.argument())));
+ restorePosition(convert<unsigned int>(to_utf8(cmd.argument())));
break;
case LFUN_LABEL_GOTO: {
- string label = lyx::to_utf8(cmd.argument());
+ docstring label = cmd.argument();
if (label.empty()) {
InsetRef * inset =
getInsetByCode<InsetRef>(cursor_,
InsetBase::REF_CODE);
if (inset) {
- label = inset->getContents();
+ label = inset->getParam("reference");
savePosition(0);
}
}
}
case LFUN_PARAGRAPH_GOTO: {
- int const id = convert<int>(lyx::to_utf8(cmd.argument()));
+ int const id = convert<int>(to_utf8(cmd.argument()));
ParIterator par = buffer_->getParFromID(id);
if (par == buffer_->par_iterator_end()) {
lyxerr[Debug::INFO] << "No matching paragraph found! ["
}
case LFUN_OUTLINE_UP:
- lyx::toc::outline(lyx::toc::Up, cursor_);
+ toc::outline(toc::Up, cursor_);
cursor_.text()->setCursor(cursor_, cursor_.pit(), 0);
updateLabels(*buffer_);
break;
case LFUN_OUTLINE_DOWN:
- lyx::toc::outline(lyx::toc::Down, cursor_);
+ toc::outline(toc::Down, cursor_);
cursor_.text()->setCursor(cursor_, cursor_.pit(), 0);
updateLabels(*buffer_);
break;
case LFUN_OUTLINE_IN:
- lyx::toc::outline(lyx::toc::In, cursor_);
+ toc::outline(toc::In, cursor_);
updateLabels(*buffer_);
break;
case LFUN_OUTLINE_OUT:
- lyx::toc::outline(lyx::toc::Out, cursor_);
+ toc::outline(toc::Out, cursor_);
updateLabels(*buffer_);
break;
}
case LFUN_CHANGE_NEXT:
- lyx::find::findNextChange(this);
+ findNextChange(this);
break;
case LFUN_CHANGES_MERGE:
- if (lyx::find::findNextChange(this))
+ if (findNextChange(this))
showDialog("changes");
break;
#ifdef WITH_WARNINGS
#warning FIXME changes
#endif
- while (lyx::find::findNextChange(this))
+ while (findNextChange(this))
getLyXText()->acceptChange(cursor_);
update();
break;
#ifdef WITH_WARNINGS
#warning FIXME changes
#endif
- while (lyx::find::findNextChange(this))
+ while (findNextChange(this))
getLyXText()->rejectChange(cursor_);
break;
}
case LFUN_WORD_FIND:
- lyx::find::find(this, cmd);
+ find(this, cmd);
break;
case LFUN_WORD_REPLACE:
- lyx::find::replace(this, cmd);
+ replace(this, cmd);
break;
case LFUN_MARK_OFF:
cur.clearSelection();
cur.resetAnchor();
- cur.message(lyx::from_utf8(N_("Mark off")));
+ cur.message(from_utf8(N_("Mark off")));
break;
case LFUN_MARK_ON:
cur.clearSelection();
cur.mark() = true;
cur.resetAnchor();
- cur.message(lyx::from_utf8(N_("Mark on")));
+ cur.message(from_utf8(N_("Mark on")));
break;
case LFUN_MARK_TOGGLE:
cur.clearSelection();
if (cur.mark()) {
cur.mark() = false;
- cur.message(lyx::from_utf8(N_("Mark removed")));
+ cur.message(from_utf8(N_("Mark removed")));
} else {
cur.mark() = true;
- cur.message(lyx::from_utf8(N_("Mark set")));
+ cur.message(from_utf8(N_("Mark set")));
}
cur.resetAnchor();
break;
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
InsetBase::BIBTEX_CODE);
if (inset) {
- if (inset->addDatabase(lyx::to_utf8(cmd.argument())))
+ if (inset->addDatabase(to_utf8(cmd.argument())))
buffer_->updateBibfilesCache();
}
break;
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
InsetBase::BIBTEX_CODE);
if (inset) {
- if (inset->delDatabase(lyx::to_utf8(cmd.argument())))
+ if (inset->delDatabase(to_utf8(cmd.argument())))
buffer_->updateBibfilesCache();
}
break;
}
-void BufferView::scroll(int lines)
+void BufferView::scroll(int /*lines*/)
{
// if (!buffer_)
// return;
}
-void BufferView::gotoLabel(string const & label)
+void BufferView::gotoLabel(docstring const & label)
{
for (InsetIterator it = inset_iterator_begin(buffer_->inset()); it; ++it) {
- vector<string> labels;
+ vector<docstring> labels;
it->getLabelList(*buffer_, labels);
- if (find(labels.begin(),labels.end(),label) != labels.end()) {
+ if (std::find(labels.begin(), labels.end(), label) != labels.end()) {
setCursor(it);
update();
return;
}
-lyx::pit_type BufferView::anchor_ref() const
+pit_type BufferView::anchor_ref() const
{
return anchor_ref_;
}
void BufferView::updateMetrics(bool singlepar)
{
+ // FIXME (Abdel 19/10/2006):
+ // There's something fishy in tabular. The coord_cache_ is not
+ // correctly reconstructed when a character is trying to be inserted.
+ // Not clearing out the coord_cache_ fixes the crash but there is a
+ // bad side effect: buffer-begin and buffer-end do not update the screen.
+ //
// Remove old position cache
- theCoords.clear();
+ coord_cache_.clear();
+
LyXText & buftext = buffer_->text();
- lyx::pit_type size = int(buftext.paragraphs().size());
+ pit_type size = int(buftext.paragraphs().size());
if (anchor_ref_ > int(buftext.paragraphs().size() - 1)) {
anchor_ref_ = int(buftext.paragraphs().size() - 1);
offset_ref_ = 0;
}
- lyx::pit_type const pit = anchor_ref_;
+ pit_type const pit = anchor_ref_;
int pit1 = pit;
int pit2 = pit;
size_t const npit = buftext.paragraphs().size();
// The coordinates of all these paragraphs are correct, cache them
int y = y1;
- CoordCache::InnerParPosCache & parPos = theCoords.parPos()[&buftext];
- for (lyx::pit_type pit = pit1; pit <= pit2; ++pit) {
+ CoordCache::InnerParPosCache & parPos = coord_cache_.parPos()[&buftext];
+ for (pit_type pit = pit1; pit <= pit2; ++pit) {
Paragraph const & par = buftext.getPar(pit);
y += par.ascent();
parPos[pit] = Point(0, y);
<< endl;
metrics_info_ = ViewMetricsInfo(pit1, pit2, y1, y2, singlepar, size);
+
+ if (lyxerr.debugging(Debug::WORKAREA)) {
+ lyxerr[Debug::WORKAREA] << "BufferView::updateMetrics" << endl;
+ coord_cache_.dump();
+ }
}
if (filename.empty()) {
// Launch a file browser
+ // FIXME UNICODE
string initpath = lyxrc.document_path;
if (buffer_) {
initpath = trypath;
}
- FileDialog fileDlg(lyx::to_utf8(_("Select LyX document to insert")),
+ // FIXME UNICODE
+ FileDialog fileDlg(_("Select LyX document to insert"),
LFUN_FILE_INSERT,
- make_pair(string(lyx::to_utf8(_("Documents|#o#O"))),
- string(lyxrc.document_path)),
- make_pair(string(lyx::to_utf8(_("Examples|#E#e"))),
- string(addPath(package().system_support(), "examples"))));
+ make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
+ make_pair(_("Examples|#E#e"), from_utf8(addPath(package().system_support(), "examples"))));
FileDialog::Result result =
- fileDlg.open(initpath,
- FileFilterList(lyx::to_utf8(_("LyX Documents (*.lyx)"))),
- string());
+ fileDlg.open(from_utf8(initpath),
+ FileFilterList(_("LyX Documents (*.lyx)")),
+ docstring());
if (result.first == FileDialog::Later)
return;
- filename = result.second;
+ // FIXME UNICODE
+ filename = to_utf8(result.second);
// check selected filename
if (filename.empty()) {
docstring res;
Buffer buf("", false);
- if (::loadLyXFile(&buf, makeAbsPath(filename))) {
+ if (lyx::loadLyXFile(&buf, makeAbsPath(filename))) {
ErrorList & el = buffer_->errorList("Parse");
// Copy the inserted document error list into the current buffer one.
el = buf.errorList("Parse");
- lyx::cap::pasteParagraphList(cursor_, buf.paragraphs(),
+ cap::pasteParagraphList(cursor_, buf.paragraphs(),
buf.params().textclass, el);
res = _("Document %1$s inserted.");
} else
buffer_->errors("Parse");
resize();
}
+
+
+} // namespace lyx
projects / lyx.git / blobdiff