#include <config.h>
#include "insettext.h"
+#include "insetnewline.h"
#include "buffer.h"
+#include "bufferparams.h"
#include "BufferView.h"
-#include "bufferview_funcs.h"
#include "CutAndPaste.h"
#include "debug.h"
-#include "dimension.h"
+#include "errorlist.h"
#include "funcrequest.h"
#include "gettext.h"
-#include "errorlist.h"
#include "intl.h"
-#include "LaTeXFeatures.h"
#include "LColor.h"
-#include "Lsstream.h"
-#include "lyxfont.h"
-#include "lyxcursor.h"
#include "lyxfind.h"
#include "lyxlex.h"
-#include "lyxrow.h"
#include "lyxrc.h"
-#include "lyxtext.h"
+#include "metricsinfo.h"
#include "paragraph.h"
-#include "ParagraphParameters.h"
-#include "trans_mgr.h"
-#include "undo_funcs.h"
-#include "WordLangTuple.h"
#include "paragraph_funcs.h"
-#include "sgml.h"
+#include "ParagraphParameters.h"
#include "rowpainter.h"
-#include "insetnewline.h"
-#include "metricsinfo.h"
-#include "textcursor.h"
+#include "sgml.h"
+#include "texrow.h"
+#include "undo.h"
+#include "WordLangTuple.h"
#include "frontends/Alert.h"
-#include "frontends/Dialogs.h"
#include "frontends/font_metrics.h"
#include "frontends/LyXView.h"
#include "frontends/Painter.h"
-#include "frontends/screen.h"
-#include "support/textutils.h"
-#include "support/LAssert.h"
-#include "support/lstrings.h"
#include "support/lyxalgo.h" // lyx::count
#include <boost/bind.hpp>
-#include <fstream>
-#include <algorithm>
-#include <cstdlib>
+using bv_funcs::replaceSelection;
+
+using lyx::pos_type;
+
+using lyx::graphics::PreviewLoader;
+
+using lyx::support::isStrUnsignedInt;
+using lyx::support::strToUnsignedInt;
-using std::ostream;
-using std::ifstream;
using std::endl;
-using std::min;
-using std::max;
-using std::make_pair;
-using std::vector;
-using std::pair;
using std::for_each;
+using std::max;
+using std::string;
using std::auto_ptr;
-
-using namespace lyx::support;
-using namespace lyx::graphics;
-using namespace bv_funcs;
-
-using lyx::pos_type;
-using lyx::textclass_type;
+using std::ostream;
+using std::vector;
InsetText::InsetText(BufferParams const & bp)
- : UpdatableInset(), text_(0, this, true, paragraphs)
-{
- paragraphs.push_back(Paragraph());
+ : UpdatableInset(),
+ paragraphs(1),
+ autoBreakRows_(false),
+ drawFrame_(NEVER),
+ frame_color_(LColor::insetframe),
+ text_(0, this, true, paragraphs)
+{
+ textwidth_ = 0; // broken
paragraphs.begin()->layout(bp.getLyXTextClass().defaultLayout());
if (bp.tracking_changes)
paragraphs.begin()->trackChanges();
- init(0);
+ init();
}
InsetText::InsetText(InsetText const & in)
- : UpdatableInset(in), text_(0, this, true, paragraphs)
+ : UpdatableInset(in),
+ text_(in.text_.bv_owner, this, true, paragraphs)
{
- init(&in);
+ // this is ugly...
+ operator=(in);
}
-InsetText & InsetText::operator=(InsetText const & it)
+void InsetText::operator=(InsetText const & in)
{
- init(&it);
- return *this;
+ UpdatableInset::operator=(in);
+ paragraphs = in.paragraphs;
+ autoBreakRows_ = in.autoBreakRows_;
+ drawFrame_ = in.drawFrame_;
+ frame_color_ = in.frame_color_;
+ textwidth_ = in.textwidth_;
+ text_ = LyXText(in.text_.bv_owner, this, true, paragraphs);
+ init();
}
-void InsetText::init(InsetText const * ins)
+void InsetText::init()
{
- if (ins) {
- textwidth_ = ins->textwidth_;
- text_.bv_owner = ins->text_.bv_owner;
-
- paragraphs = ins->paragraphs;
-
- ParagraphList::iterator pit = paragraphs.begin();
- ParagraphList::iterator end = paragraphs.end();
- for (; pit != end; ++pit)
- pit->setInsetOwner(this);
-
- autoBreakRows = ins->autoBreakRows;
- drawFrame_ = ins->drawFrame_;
- frame_color = ins->frame_color;
- } else {
- textwidth_ = 0; // broken
- drawFrame_ = NEVER;
- frame_color = LColor::insetframe;
- autoBreakRows = false;
- }
- the_locking_inset = 0;
- for_each(paragraphs.begin(), paragraphs.end(),
- boost::bind(&Paragraph::setInsetOwner, _1, this));
+ ParagraphList::iterator pit = paragraphs.begin();
+ ParagraphList::iterator end = paragraphs.end();
+ for (; pit != end; ++pit)
+ pit->setInsetOwner(this);
+ text_.paragraphs_ = ¶graphs;
top_y = 0;
- no_selection = true;
- drawTextXOffset = 0;
- drawTextYOffset = 0;
+
locked = false;
- old_par = paragraphs.end();
+ inset_par = -1;
+ inset_pos = 0;
+ inset_x = 0;
+ inset_y = 0;
+ no_selection = true;
+ the_locking_inset = 0;
+ old_par = -1;
in_insetAllowed = false;
+ mouse_x = 0;
+ mouse_y = 0;
}
if (just_mark_erased) {
ParagraphList::iterator it = paragraphs.begin();
ParagraphList::iterator end = paragraphs.end();
- for (; it != end; ++it)
+ for (; it != end; ++it)
it->markErased();
return;
}
}
-void InsetText::write(Buffer const * buf, ostream & os) const
+void InsetText::write(Buffer const & buf, ostream & os) const
{
os << "Text\n";
writeParagraphData(buf, os);
}
-void InsetText::writeParagraphData(Buffer const * buf, ostream & os) const
+void InsetText::writeParagraphData(Buffer const & buf, ostream & os) const
{
ParagraphList::const_iterator it = paragraphs.begin();
ParagraphList::const_iterator end = paragraphs.end();
Paragraph::depth_type dth = 0;
for (; it != end; ++it) {
- it->write(buf, os, buf->params, dth);
+ it->write(buf, os, buf.params(), dth);
}
}
-void InsetText::read(Buffer const * buf, LyXLex & lex)
+void InsetText::read(Buffer const & buf, LyXLex & lex)
{
string token;
Paragraph::depth_type depth = 0;
clear(false);
- if (buf->params.tracking_changes)
+#warning John, look here. Doesnt make much sense.
+ if (buf.params().tracking_changes)
paragraphs.begin()->trackChanges();
// delete the initial paragraph
+ Paragraph oldpar = *paragraphs.begin();
paragraphs.clear();
ParagraphList::iterator pit = paragraphs.begin();
}
// FIXME: ugly.
- const_cast<Buffer*>(buf)->readParagraph(lex, token, paragraphs, pit, depth);
+ const_cast<Buffer&>(buf).readParagraph(lex, token, paragraphs, pit, depth);
}
pit = paragraphs.begin();
lex.printError("Missing \\end_inset at this point. "
"Read: `$$Token'");
}
+
+ // sanity check
+ // ensure we have at least one par.
+ if (paragraphs.empty())
+ paragraphs.push_back(oldpar);
}
top_baseline = y;
top_y = y - dim_.asc;
- if (the_locking_inset && cpar() == inset_par && cpos() == inset_pos) {
- inset_x = cix() - x + drawTextXOffset;
- inset_y = ciy() + drawTextYOffset;
+ if (the_locking_inset
+ && text_.cursor.par() == inset_par && cpos() == inset_pos) {
+ inset_x = cx() - x;
+ inset_y = cy();
}
x += TEXT_TO_INSET_OFFSET;
int const frame_y = top_baseline - dim_.asc + ttoD2;
int const frame_w = dim_.wid - TEXT_TO_INSET_OFFSET;
int const frame_h = dim_.asc + dim_.des - TEXT_TO_INSET_OFFSET;
- pain.rectangle(frame_x, frame_y, frame_w, frame_h, frame_color);
+ pain.rectangle(frame_x, frame_y, frame_w, frame_h, frameColor());
}
if (!bv)
return;
- if (!autoBreakRows && paragraphs.size() > 1)
+ if (!autoBreakRows_ && paragraphs.size() > 1)
collapseParagraphs(bv);
if (!text_.selection.set())
bv->owner()->view_state_changed();
bv->owner()->updateMenubar();
bv->owner()->updateToolbar();
- if (old_par != cpar()) {
+ if (old_par != text_.cursor.par()) {
bv->owner()->setLayout(cpar()->layout()->name());
- old_par = cpar();
+ old_par = text_.cursor.par();
}
}
no_selection = true;
locked = false;
- if (text_.selection.set()) {
+ if (text_.selection.set())
text_.clearSelection();
- } else if (owner()) {
+ else if (owner())
bv->owner()->setLayout(owner()->getLyXText(bv)
- ->cursor.par()->layout()->name());
- } else
- bv->owner()->setLayout(bv->text->cursor.par()->layout()->name());
+ ->cursorPar()->layout()->name());
+ else
+ bv->owner()->setLayout(bv->text->cursorPar()->layout()->name());
// hack for deleteEmptyParMech
- ParagraphList::iterator first_par = paragraphs.begin();
- if (!first_par->empty()) {
- text_.setCursor(first_par, 0);
- } else if (paragraphs.size() > 1) {
- text_.setCursor(boost::next(first_par), 0);
- }
+ if (!paragraphs.begin()->empty())
+ text_.setCursor(0, 0);
+ else if (paragraphs.size() > 1)
+ text_.setCursor(1, 0);
}
the_locking_inset = 0;
inset_pos = inset_x = inset_y = 0;
inset_boundary = false;
- inset_par = paragraphs.end();
- old_par = paragraphs.end();
- text_.setCursorIntern(paragraphs.begin(), 0);
+ inset_par = -1;
+ old_par = -1;
+ text_.setCursorIntern(0, 0);
text_.clearSelection();
finishUndo();
// If the inset is empty set the language of the current font to the
void InsetText::lockInset(BufferView * /*bv*/, UpdatableInset * inset)
{
the_locking_inset = inset;
- inset_x = cix() - top_x + drawTextXOffset;
- inset_y = ciy() + drawTextYOffset;
+ inset_x = cx() - top_x;
+ inset_y = cy();
inset_pos = cpos();
- inset_par = cpar();
+ inset_par = text_.cursor.par();
inset_boundary = cboundary();
}
ParagraphList::iterator pit = paragraphs.begin();
ParagraphList::iterator pend = paragraphs.end();
- int const id = inset->id();
for (; pit != pend; ++pit) {
InsetList::iterator it = pit->insetlist.begin();
InsetList::iterator const end = pit->insetlist.end();
for (; it != end; ++it) {
if (it->inset == inset) {
lyxerr << "InsetText::lockInsetInInset: 1 a" << endl;
- text_.setCursorIntern(pit, it->pos);
+ text_.setCursorIntern(
+ std::distance(paragraphs.begin(), pit), it->pos);
lyxerr << "InsetText::lockInsetInInset: 1 b" << endl;
lyxerr << "bv: " << bv << " inset: " << inset << endl;
lockInset(bv, inset);
lyxerr << "InsetText::lockInsetInInset: 1 c" << endl;
return true;
}
- if (it->inset->getInsetFromID(id)) {
- lyxerr << "InsetText::lockInsetInInset: 2" << endl;
- text_.setCursorIntern(pit, it->pos);
- it->inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT));
- return the_locking_inset->lockInsetInInset(bv, inset);
- }
}
}
lyxerr << "InsetText::lockInsetInInset: 3" << endl;
}
if (the_locking_inset && the_locking_inset == inset) {
- if (cpar() == inset_par && cpos() == inset_pos) {
+ if (text_.cursor.par() == inset_par && cpos() == inset_pos) {
lyxerr[Debug::INSETS] << "OK" << endl;
- inset_x = cix() - top_x + drawTextXOffset;
- inset_y = ciy() + drawTextYOffset;
+ inset_x = cx() - top_x;
+ inset_y = cy();
} else {
lyxerr[Debug::INSETS] << "cursor.pos != inset_pos" << endl;
}
the_locking_inset = 0;
if (lr)
moveRightIntern(bv, true, false);
- old_par = paragraphs.end(); // force layout setting
+ old_par = -1; // force layout setting
if (scroll())
scroll(bv, 0.0F);
else
if (!locked)
lockInset(bv);
- int tmp_x = cmd.x - drawTextXOffset;
+ int tmp_x = cmd.x;
int tmp_y = cmd.y + dim_.asc - bv->top_y();
InsetOld * inset = getLyXText(bv)->checkInsetHit(tmp_x, tmp_y);
if (the_locking_inset) {
if (the_locking_inset == inset) {
- the_locking_inset->localDispatch(cmd1);
+ the_locking_inset->dispatch(cmd1);
return;
}
// otherwise only unlock the_locking_inset
if (!bv->lockInset(uinset)) {
lyxerr[Debug::INSETS] << "Cannot lock inset" << endl;
}
- inset->localDispatch(cmd1);
+ inset->dispatch(cmd1);
if (the_locking_inset)
updateLocal(bv, false);
return;
if (!inset) {
bool paste_internally = false;
if (cmd.button() == mouse_button::button2 && getLyXText(bv)->selection.set()) {
- localDispatch(FuncRequest(bv, LFUN_COPY));
+ dispatch(FuncRequest(bv, LFUN_COPY));
paste_internally = true;
}
int old_top_y = bv->top_y();
- text_.setCursorFromCoordinates(cmd.x - drawTextXOffset,
- cmd.y + dim_.asc);
+ text_.setCursorFromCoordinates(cmd.x, cmd.y + dim_.asc);
// set the selection cursor!
text_.selection.cursor = text_.cursor;
text_.cursor.x_fix(text_.cursor.x());
// we moved the view we cannot do mouse selection in this case!
if (bv->top_y() != old_top_y)
no_selection = true;
- old_par = cpar();
+ old_par = text_.cursor.par();
// Insert primary selection with middle mouse
// if there is a local selection in the current buffer,
// insert this
if (cmd.button() == mouse_button::button2) {
if (paste_internally)
- localDispatch(FuncRequest(bv, LFUN_PASTE));
+ dispatch(FuncRequest(bv, LFUN_PASTE));
else
- localDispatch(FuncRequest(bv, LFUN_PASTESELECTION, "paragraph"));
+ dispatch(FuncRequest(bv, LFUN_PASTESELECTION, "paragraph"));
}
} else {
getLyXText(bv)->clearSelection();
no_selection = true;
if (the_locking_inset)
- return the_locking_inset->localDispatch(cmd1);
+ return the_locking_inset->dispatch(cmd1);
- int tmp_x = cmd.x - drawTextXOffset;
+ int tmp_x = cmd.x;
int tmp_y = cmd.y + dim_.asc - bv->top_y();
InsetOld * inset = getLyXText(bv)->checkInsetHit(tmp_x, tmp_y);
- bool ret = false;
- if (inset) {
-// This code should probably be removed now. Simple insets
-// (!highlyEditable) can actually take the localDispatch,
-// and turn it into edit() if necessary. But we still
-// need to deal properly with the whole relative vs.
-// absolute mouse co-ords thing in a realiable, sensible way
-#if 0
- if (isHighlyEditableInset(inset))
- ret = inset->localDispatch(cmd1);
- else {
- inset_x = cix(bv) - top_x + drawTextXOffset;
- inset_y = ciy() + drawTextYOffset;
- cmd1.x = cmd.x - inset_x;
- cmd1.y = cmd.x - inset_y;
- inset->edit(bv, cmd1.x, cmd1.y, cmd.button());
- ret = true;
- }
-#endif
- ret = inset->localDispatch(cmd1);
- updateLocal(bv, false);
+ if (!inset)
+ return false;
- }
+ // We still need to deal properly with the whole relative vs.
+ // absolute mouse co-ords thing in a realiable, sensible way
+ bool ret = inset->dispatch(cmd1);
+ updateLocal(bv, false);
return ret;
}
cmd1.y -= inset_y;
if (the_locking_inset) {
- the_locking_inset->localDispatch(cmd1);
+ the_locking_inset->dispatch(cmd1);
return;
}
BufferView * bv = cmd.view();
LyXCursor cur = text_.cursor;
- text_.setCursorFromCoordinates
- (cmd.x - drawTextXOffset, cmd.y + dim_.asc);
+ text_.setCursorFromCoordinates (cmd.x, cmd.y + dim_.asc);
text_.cursor.x_fix(text_.cursor.x());
if (cur == text_.cursor)
return;
}
-InsetOld::RESULT InsetText::localDispatch(FuncRequest const & cmd)
+dispatch_result
+InsetText::priv_dispatch(FuncRequest const & cmd,
+ idx_type & idx, pos_type & pos)
{
BufferView * bv = cmd.view();
setViewCache(bv);
switch (cmd.action) {
case LFUN_INSET_EDIT: {
- UpdatableInset::localDispatch(cmd);
+ UpdatableInset::priv_dispatch(cmd, idx, pos);
if (!bv->lockInset(this)) {
lyxerr[Debug::INSETS] << "Cannot lock inset" << endl;
inset_x = 0;
inset_y = 0;
inset_boundary = false;
- inset_par = paragraphs.end();
- old_par = paragraphs.end();
+ inset_par = -1;
+ old_par = -1;
if (cmd.argument.size()) {
if (cmd.argument == "left")
- text_.setCursorIntern(paragraphs.begin(), 0);
- else {
- ParagraphList::iterator it = boost::prior(paragraphs.end());
- text_.setCursor(it, it->size());
- }
+ text_.setCursorIntern(0, 0);
+ else
+ text_.setCursor(paragraphs.size() - 1, paragraphs.back().size());
} else {
int tmp_y = (cmd.y < 0) ? 0 : cmd.y;
// we put here -1 and not button as now the button in the
// cycle hopefully (Jug 20020509)
// FIXME: GUII I've changed this to none: probably WRONG
if (!checkAndActivateInset(bv, cmd.x, tmp_y, mouse_button::none)) {
- text_.setCursorFromCoordinates(cmd.x - drawTextXOffset,
- cmd.y + dim_.asc);
+ text_.setCursorFromCoordinates(cmd.x, cmd.y + dim_.asc);
text_.cursor.x(text_.cursor.x());
text_.cursor.x_fix(text_.cursor.x());
}
bool was_empty = paragraphs.begin()->empty() && paragraphs.size() == 1;
no_selection = false;
- RESULT result = UpdatableInset::localDispatch(cmd);
+ dispatch_result result = UpdatableInset::priv_dispatch(cmd, idx, pos);
if (result != UNDISPATCHED)
return DISPATCHED;
return FINISHED;
if (the_locking_inset) {
- result = the_locking_inset->localDispatch(cmd);
+ result = the_locking_inset->dispatch(cmd);
if (result == DISPATCHED_NOUPDATE)
return result;
if (result == DISPATCHED) {
* true (on). */
#if 0
// This should not be needed here and is also WRONG!
- recordUndo(bv, Undo::INSERT, text_.cursor.par());
+ recordUndo(bv, Undo::INSERT, text_.cursorPar());
#endif
bv->switchKeyMap();
case LFUN_DELETE:
if (text_.selection.set())
text_.cutSelection(true, false);
- else
+ else
text_.Delete();
updflag = true;
break;
- case LFUN_PASTE: {
- if (!autoBreakRows) {
+ case LFUN_PASTE:
+ if (!autoBreakRows_) {
if (CutAndPaste::nrOfParagraphs() > 1) {
#ifdef WITH_WARNINGS
#warning FIXME horrendously bad UI
#endif
Alert::error(_("Paste failed"), _("Cannot include more than one paragraph."));
- break;
}
- }
-
- replaceSelection(bv->getLyXText());
- size_t sel_index = 0;
- string const & arg = cmd.argument;
- if (isStrUnsignedInt(arg)) {
- size_t const paste_arg = strToUnsignedInt(arg);
+ } else {
+ replaceSelection(bv->getLyXText());
+ size_t sel_index = 0;
+ string const & arg = cmd.argument;
+ if (isStrUnsignedInt(arg)) {
#warning FIXME Check if the arg is in the domain of available selections.
- sel_index = paste_arg;
+ sel_index = strToUnsignedInt(arg);
+ }
+ text_.pasteSelection(sel_index);
+ // bug 393
+ text_.clearSelection();
+ updflag = true;
}
- text_.pasteSelection(sel_index);
- // bug 393
- text_.clearSelection();
- updflag = true;
break;
- }
case LFUN_BREAKPARAGRAPH:
- if (!autoBreakRows) {
+ if (!autoBreakRows_) {
result = DISPATCHED;
- break;
+ } else {
+ replaceSelection(bv->getLyXText());
+ text_.breakParagraph(paragraphs, 0);
+ updflag = true;
}
- replaceSelection(bv->getLyXText());
- text_.breakParagraph(paragraphs, 0);
- updflag = true;
break;
case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
- if (!autoBreakRows) {
+ if (!autoBreakRows_) {
result = DISPATCHED;
- break;
+ } else {
+ replaceSelection(bv->getLyXText());
+ text_.breakParagraph(paragraphs, 1);
+ updflag = true;
}
- replaceSelection(bv->getLyXText());
- text_.breakParagraph(paragraphs, 1);
- updflag = true;
break;
case LFUN_BREAKLINE: {
- if (!autoBreakRows) {
+ if (!autoBreakRows_) {
result = DISPATCHED;
- break;
+ } else {
+ replaceSelection(bv->getLyXText());
+ text_.insertInset(new InsetNewline);
+ updflag = true;
}
-
- replaceSelection(bv->getLyXText());
- text_.insertInset(new InsetNewline);
- updflag = true;
break;
}
case LFUN_LAYOUT:
// do not set layouts on non breakable textinsets
- if (autoBreakRows) {
+ if (autoBreakRows_) {
string cur_layout = cpar()->layout()->name();
// Derive layout number from given argument (string)
- // and current buffer's textclass (number).
+ // and current buffer's textclass (number).
LyXTextClass const & tclass =
- bv->buffer()->params.getLyXTextClass();
+ bv->buffer()->params().getLyXTextClass();
string layout = cmd.argument;
bool hasLayout = tclass.hasLayout(layout);
}
-int InsetText::latex(Buffer const * buf, ostream & os,
+int InsetText::latex(Buffer const & buf, ostream & os,
LatexRunParams const & runparams) const
{
TexRow texrow;
}
-int InsetText::ascii(Buffer const * buf, ostream & os, int linelen) const
+int InsetText::ascii(Buffer const & buf, ostream & os, int linelen) const
{
unsigned int lines = 0;
ParagraphList::const_iterator end = paragraphs.end();
ParagraphList::const_iterator it = beg;
for (; it != end; ++it) {
- string const tmp = buf->asciiParagraph(*it, linelen, it == beg);
+ string const tmp = buf.asciiParagraph(*it, linelen, it == beg);
lines += lyx::count(tmp.begin(), tmp.end(), '\n');
os << tmp;
}
}
-int InsetText::linuxdoc(Buffer const * buf, ostream & os) const
+int InsetText::linuxdoc(Buffer const & buf, ostream & os) const
{
ParagraphList::iterator pit = const_cast<ParagraphList&>(paragraphs).begin();
ParagraphList::iterator pend = const_cast<ParagraphList&>(paragraphs).end();
const string name = pit->layout()->latexname();
if (name != "p")
sgml::openTag(os, 1, 0, name);
- buf->simpleLinuxDocOnePar(os, pit, 0);
+ buf.simpleLinuxDocOnePar(os, pit, 0);
if (name != "p")
sgml::closeTag(os, 1, 0, name);
}
}
-int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const
+int InsetText::docbook(Buffer const & buf, ostream & os, bool mixcont) const
{
unsigned int lines = 0;
break;
case LATEX_COMMAND:
- buf->error(ErrorItem(_("Error"), _("LatexType Command not allowed here.\n"), pit->id(), 0, pit->size()));
+ buf.error(ErrorItem(_("Error"), _("LatexType Command not allowed here.\n"), pit->id(), 0, pit->size()));
return -1;
break;
break;
}
- buf->simpleDocBookOnePar(os, pit, desc_on, depth + 1 + command_depth);
+ buf.simpleDocBookOnePar(os, pit, desc_on, depth + 1 + command_depth);
string end_tag;
// write closing SGML tags
}
-InsetOld::RESULT InsetText::moveRight(BufferView * bv)
+dispatch_result InsetText::moveRight(BufferView * bv)
{
- if (text_.cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ if (text_.cursorPar()->isRightToLeftPar(bv->buffer()->params()))
return moveLeftIntern(bv, false, true, false);
else
return moveRightIntern(bv, true, true, false);
}
-InsetOld::RESULT InsetText::moveLeft(BufferView * bv)
+dispatch_result InsetText::moveLeft(BufferView * bv)
{
- if (text_.cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ if (text_.cursorPar()->isRightToLeftPar(bv->buffer()->params()))
return moveRightIntern(bv, true, true, false);
else
return moveLeftIntern(bv, false, true, false);
}
-InsetOld::RESULT
+dispatch_result
InsetText::moveRightIntern(BufferView * bv, bool front,
bool activate_inset, bool selecting)
{
}
-InsetOld::RESULT
+dispatch_result
InsetText::moveLeftIntern(BufferView * bv, bool front,
bool activate_inset, bool selecting)
{
}
-InsetOld::RESULT InsetText::moveUp(BufferView * bv)
+dispatch_result InsetText::moveUp(BufferView * bv)
{
if (crow() == text_.firstRow())
return FINISHED_UP;
}
-InsetOld::RESULT InsetText::moveDown(BufferView * bv)
+dispatch_result InsetText::moveDown(BufferView * bv)
{
if (crow() == text_.lastRow())
return FINISHED_DOWN;
}
-void InsetText::getLabelList(std::vector<string> & list) const
+void InsetText::getLabelList(Buffer const & buffer,
+ std::vector<string> & list) const
{
ParagraphList::const_iterator pit = paragraphs.begin();
ParagraphList::const_iterator pend = paragraphs.end();
InsetList::const_iterator beg = pit->insetlist.begin();
InsetList::const_iterator end = pit->insetlist.end();
for (; beg != end; ++beg)
- beg->inset->getLabelList(list);
+ beg->inset->getLabelList(buffer, list);
}
}
if (text_.selection.set())
- recordUndo(bv, Undo::ATOMIC, text_.cursor.par());
+ text_.recUndo(text_.cursor.par());
if (selectall) {
text_.cursorTop();
if (!isHighlyEditableInset(inset))
return false;
FuncRequest cmd(bv, LFUN_INSET_EDIT, front ? "left" : "right");
- inset->localDispatch(cmd);
+ inset->dispatch(cmd);
if (!the_locking_inset)
return false;
updateLocal(bv, false);
bool InsetText::checkAndActivateInset(BufferView * bv, int x, int y,
mouse_button::state button)
{
- x -= drawTextXOffset;
int dummyx = x;
int dummyy = y + dim_.asc;
InsetOld * inset = getLyXText(bv)->checkInsetHit(dummyx, dummyy);
x = dim_.wid;
if (y < 0)
y = dim_.des;
- inset_x = cix() - top_x + drawTextXOffset;
- inset_y = ciy() + drawTextYOffset;
+ inset_x = cx() - top_x;
+ inset_y = cy();
FuncRequest cmd(bv, LFUN_INSET_EDIT, x - inset_x, y - inset_y, button);
- inset->localDispatch(cmd);
+ inset->dispatch(cmd);
if (!the_locking_inset)
return false;
updateLocal(bv, false);
void InsetText::setAutoBreakRows(bool flag)
{
- if (flag != autoBreakRows) {
- autoBreakRows = flag;
+ if (flag != autoBreakRows_) {
+ autoBreakRows_ = flag;
if (!flag)
removeNewlines();
}
}
-void InsetText::setFrameColor(LColor::color col)
+LColor_color InsetText::frameColor() const
{
- frame_color = col;
+ return LColor::color(frame_color_);
}
-int InsetText::cx() const
+void InsetText::setFrameColor(LColor_color col)
{
- int x = text_.cursor.x() + top_x + TEXT_TO_INSET_OFFSET;
- if (the_locking_inset) {
- LyXFont font = text_.getFont(text_.cursor.par(), text_.cursor.pos());
- if (font.isVisibleRightToLeft())
- x -= the_locking_inset->width();
- }
- return x;
+ frame_color_ = col;
}
-int InsetText::cix() const
+int InsetText::cx() const
{
- int x = text_.cursor.ix() + top_x + TEXT_TO_INSET_OFFSET;
+ int x = text_.cursor.x() + top_x + TEXT_TO_INSET_OFFSET;
if (the_locking_inset) {
- LyXFont font = text_.getFont(text_.cursor.par(), text_.cursor.pos());
+ LyXFont font = text_.getFont(text_.cursorPar(), text_.cursor.pos());
if (font.isVisibleRightToLeft())
x -= the_locking_inset->width();
}
}
-int InsetText::ciy() const
-{
- return text_.cursor.iy() - dim_.asc + TEXT_TO_INSET_OFFSET;
-}
-
-
pos_type InsetText::cpos() const
{
return text_.cursor.pos();
ParagraphList::iterator InsetText::cpar() const
{
- return text_.cursor.par();
+ return text_.cursorPar();
}
}
-void InsetText::clearSelection(BufferView * bv)
+void InsetText::clearSelection(BufferView *)
{
text_.clearSelection();
}
}
if (ty + h > pain.paperHeight())
h = pain.paperHeight();
- if (top_x + drawTextXOffset + w > pain.paperWidth())
+ if (top_x + w > pain.paperWidth())
w = pain.paperWidth();
pain.fillRectangle(start_x + 1, ty + 1, w - 3, h - 1, backgroundColor());
}
}
+LyXText * InsetText::getText(int i) const
+{
+ return (i == 0) ? const_cast<LyXText*>(&text_) : 0;
+}
+
+
LyXCursor const & InsetText::cursor(BufferView * bv) const
{
if (the_locking_inset)
return true;
}
if (!locked) {
- ParagraphList::iterator pit = boost::prior(paragraphs.end());
- text_.setCursor(pit, pit->size());
+ text_.setCursor(paragraphs.size() - 1, paragraphs.back().size());
}
lyx::find::SearchResult result =
lyx::find::find(bv, &text_, str, false, cs, mw);
void InsetText::collapseParagraphs(BufferView * bv)
{
while (paragraphs.size() > 1) {
- ParagraphList::iterator first_par = paragraphs.begin();
- ParagraphList::iterator next_par = boost::next(first_par);
- size_t const first_par_size = first_par->size();
-
- if (!first_par->empty() &&
- !next_par->empty() &&
- !first_par->isSeparator(first_par_size - 1)) {
- first_par->insertChar(first_par_size, ' ');
+ ParagraphList::iterator const first = paragraphs.begin();
+ ParagraphList::iterator second = first;
+ advance(second, 1);
+ size_t const first_par_size = first->size();
+
+ if (!first->empty() &&
+ !second->empty() &&
+ !first->isSeparator(first_par_size - 1)) {
+ first->insertChar(first_par_size, ' ');
}
+#warning probably broken
if (text_.selection.set()) {
- if (text_.selection.start.par() == next_par) {
- text_.selection.start.par(first_par);
- text_.selection.start.pos(
- text_.selection.start.pos() + first_par_size);
+ if (text_.selection.start.par() == 1) {
+ text_.selection.start.par(1);
+ text_.selection.start.pos(text_.selection.start.pos() + first_par_size);
}
- if (text_.selection.end.par() == next_par) {
- text_.selection.end.par(first_par);
- text_.selection.end.pos(
- text_.selection.end.pos() + first_par_size);
+ if (text_.selection.end.par() == 2) {
+ text_.selection.end.par(1);
+ text_.selection.end.pos(text_.selection.end.pos() + first_par_size);
}
}
- mergeParagraph(bv->buffer()->params, paragraphs, first_par);
+ mergeParagraph(bv->buffer()->params(), paragraphs, first);
}
}
ParagraphList::iterator pit = plist.begin();
ParagraphList::iterator ins = paragraphs.insert(paragraphs.end(), *pit);
++pit;
- mergeParagraph(buffer->params, paragraphs, boost::prior(ins));
+ mergeParagraph(buffer->params(), paragraphs, boost::prior(ins));
ParagraphList::iterator pend = plist.end();
for (; pit != pend; ++pit)