-/* This file is part of
- * ======================================================
- *
- * LyX, The Document Processor
- *
- * Copyright 1998 The LyX Team.
+/**
+ * \file insetert.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- *======================================================*/
-
+ * \author Jürgen Vigna
+ * \author Lars Gullik Bjønnes
+ *
+ * Full author contact details are available in file CREDITS
+ */
#include <config.h>
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
#include "insetert.h"
-#include "gettext.h"
-#include "lyxfont.h"
+#include "insettext.h"
+
#include "buffer.h"
-#include "insets/insettext.h"
-#include "support/LOstream.h"
-#include "lyx_gui_misc.h"
#include "BufferView.h"
-#include "LyXView.h"
+#include "debug.h"
+#include "funcrequest.h"
+#include "gettext.h"
+#include "language.h"
+#include "lyxfont.h"
+#include "lyxlex.h"
+#include "lyxrow.h"
#include "lyxtext.h"
+#include "WordLangTuple.h"
+
+#include "frontends/Alert.h"
#include "frontends/Dialogs.h"
-#include "debug.h"
+#include "frontends/LyXView.h"
+
+#include "support/LOstream.h"
+#include "support/LAssert.h"
+#include "support/lstrings.h"
+
using std::ostream;
+using std::min;
+using std::endl;
+
+using lyx::pos_type;
+
void InsetERT::init()
{
labelfont.decSize();
labelfont.setColor(LColor::latex);
setInsetName("ERT");
-
}
-InsetERT::InsetERT(bool collapsed)
- : InsetCollapsable(collapsed)
+InsetERT::InsetERT(BufferParams const & bp, bool collapsed)
+ : InsetCollapsable(bp, collapsed)
{
if (collapsed)
status_ = Collapsed;
}
-InsetERT::InsetERT(string const & contents, bool collapsed)
- : InsetCollapsable(collapsed)
+InsetERT::InsetERT(BufferParams const & bp,
+ Language const * l, string const & contents, bool collapsed)
+ : InsetCollapsable(bp, collapsed)
{
- LyXFont font(LyXFont::ALL_INHERIT);
+ if (collapsed)
+ status_ = Collapsed;
+ else
+ status_ = Open;
+
+ LyXFont font(LyXFont::ALL_INHERIT, l);
+#ifdef SET_HARD_FONT
font.setFamily(LyXFont::TYPEWRITER_FAMILY);
font.setColor(LColor::latex);
+#endif
+
string::const_iterator cit = contents.begin();
string::const_iterator end = contents.end();
- Paragraph::size_type pos = 0;
+ pos_type pos = 0;
for (; cit != end; ++cit) {
inset.paragraph()->insertChar(pos++, *cit, font);
}
InsetERT::~InsetERT()
{
- hideDialog();
+ InsetERTMailer mailer(*this);
+ mailer.hideDialog();
}
if (token == "status") {
lex.next();
string const tmp_token = lex.getString();
-
+
if (tmp_token == "Inlined") {
status(0, Inlined);
} else if (tmp_token == "Collapsed") {
// leave this as default!
status(0, Open);
}
-
+
token_found = true;
} else {
lyxerr << "InsetERT::Read: Missing 'status'-tag!"
- << std::endl;
+ << endl;
// take countermeasures
lex.pushToken(token);
}
}
+#if 0
#warning this should be really short lived only for compatibility to
#warning files written 07/08/2001 so this has to go before 1.2.0! (Jug)
if (lex.isOK()) {
lex.pushToken(token);
}
}
+#endif
inset.read(buf, lex);
+
+#ifdef SET_HARD_FONT
+ LyXFont font(LyXFont::ALL_INHERIT, latex_language);
+ font.setFamily(LyXFont::TYPEWRITER_FAMILY);
+ font.setColor(LColor::latex);
+ Paragraph * par = inset.paragraph();
+ while (par) {
+ pos_type siz = par->size();
+ for (pos_type i = 0; i < siz; ++i) {
+ par->setFont(i, font);
+ }
+ par = par->next();
+ }
+#endif
+
if (!token_found) {
if (collapsed_) {
status(0, Collapsed);
}
-void InsetERT::write(Buffer const * buf, ostream & os) const
+void InsetERT::write(Buffer const * buf, ostream & os) const
{
string st;
- switch(status_) {
- case Open:
+ switch (status_) {
+ case Open:
st = "Open";
break;
case Collapsed:
os << getInsetName() << "\n"
<< "status "<< st << "\n";
- inset.writeParagraphData(buf, os);
+ //inset.writeParagraphData(buf, os);
+ string const layout(buf->params.getLyXTextClass().defaultLayoutName());
+ Paragraph * par = inset.paragraph();
+ while (par) {
+ os << "\n\\layout " << layout << "\n";
+ pos_type siz = par->size();
+ for (pos_type i = 0; i < siz; ++i) {
+ Paragraph::value_type c = par->getChar(i);
+ switch (c) {
+ case Paragraph::META_INSET:
+ if (par->getInset(i)->lyxCode() != Inset::NEWLINE_CODE) {
+ lyxerr << "Element is not allowed in insertERT"
+ << endl;
+ } else {
+ par->getInset(i)->write(buf, os);
+ }
+ break;
+
+ case '\\':
+ os << "\n\\backslash \n";
+ break;
+ default:
+ os << c;
+ break;
+ }
+ }
+ par = par->next();
+ }
}
-string const InsetERT::editMessage() const
+string const InsetERT::editMessage() const
{
return _("Opened ERT Inset");
}
void InsetERT::setFont(BufferView *, LyXFont const &, bool, bool selectall)
{
+#ifdef WITH_WARNINGS
+#warning FIXME. More UI stupidity...
+#endif
// if selectall is activated then the fontchange was an outside general
// fontchange and this messages is not needed
if (!selectall)
- WriteAlert(_("Impossible Operation!"),
- _("Not permitted to change font-types inside ERT-insets!"),
- _("Sorry."));
+ Alert::error(_("Cannot change font"),
+ _("You cannot change font settings inside TeX code."));
}
-void InsetERT::edit(BufferView * bv, int x, int y, unsigned int button)
+void InsetERT::updateStatus(BufferView * bv, bool swap) const
+{
+ if (status_ != Inlined) {
+ if (collapsed_) {
+ status(bv, swap ? Open : Collapsed);
+ } else {
+ status(bv, swap ? Collapsed : Open);
+ }
+ }
+}
+
+void InsetERT::edit(BufferView * bv, int x, int y, mouse_button::state button)
{
- InsetCollapsable::edit(bv, x, y, button);
+ if (button == mouse_button::button3)
+ return;
+
+ if (status_ == Inlined) {
+ if (!bv->lockInset(this))
+ return;
+ inset.edit(bv, x, y, button);
+ } else {
+ InsetCollapsable::edit(bv, x, y, button);
+ }
set_latex_font(bv);
+ updateStatus(bv);
}
void InsetERT::edit(BufferView * bv, bool front)
{
InsetCollapsable::edit(bv, front);
+ updateStatus(0);
set_latex_font(bv);
}
-void InsetERT::insetButtonRelease(BufferView * bv, int x, int y, int button)
+void InsetERT::lfunMousePress(FuncRequest const & cmd)
{
- if (button == 3) {
+ if (status_ == Inlined)
+ inset.localDispatch(cmd);
+ else
+ InsetCollapsable::localDispatch(cmd);
+}
+
+
+bool InsetERT::lfunMouseRelease(FuncRequest const & cmd)
+{
+ BufferView * bv = cmd.view();
+
+ if (cmd.button() == mouse_button::button3) {
showInsetDialog(bv);
- return;
+ return true;
}
- if ((x >= 0) && (x < button_length) &&
- (y >= button_top_y) && (y <= button_bottom_y))
- {
-// if (collapsed_) {
-// setLabel(_("ERT"));
-// } else {
-// setLabel(get_new_label());
-// }
- if (collapsed_) {
- status(bv, Open);
-// collapsed_ = false;
-// inset.insetButtonRelease(bv, 0, 0, button);
-// inset.setUpdateStatus(bv, InsetText::FULL);
-// bv->updateInset(this, true);
- } else {
- status(bv, Collapsed);
-// collapsed_ = true;
-// bv->unlockInset(this);
-// bv->updateInset(this, true);
- }
- } else if (!collapsed_ && (y > button_bottom_y)) {
+
+ if (status_ != Inlined && (cmd.x >= 0) && (cmd.x < button_length) &&
+ (cmd.y >= button_top_y) && (cmd.y <= button_bottom_y)) {
+ updateStatus(bv, true);
+ } else {
LyXFont font(LyXFont::ALL_SANE);
- int yy = ascent(bv, font) + y -
- (ascent_collapsed() +
- descent_collapsed() +
- inset.ascent(bv, font));
- inset.insetButtonRelease(bv, x, yy, button);
+ FuncRequest cmd1 = cmd;
+ cmd1.y = ascent(bv, font) + cmd.y - inset.ascent(bv, font);
+
+ // inlined is special - the text appears above
+ // button_bottom_y
+ if (status_ == Inlined)
+ inset.localDispatch(cmd1);
+ else if (!collapsed_ && (cmd.y > button_bottom_y)) {
+ cmd1.y -= ascent_collapsed() + descent_collapsed();
+ inset.localDispatch(cmd1);
+ }
}
+ return false;
+}
+
+
+void InsetERT::lfunMouseMotion(FuncRequest const & cmd)
+{
+ if (status_ == Inlined)
+ inset.localDispatch(cmd);
+ else
+ InsetCollapsable::localDispatch(cmd);
}
-int InsetERT::latex(Buffer const *, std::ostream & os, bool /*fragile*/,
+int InsetERT::latex(Buffer const *, ostream & os, bool /*fragile*/,
bool /*free_spc*/) const
{
Paragraph * par = inset.paragraph();
+ int lines = 0;
while (par) {
- Paragraph::size_type siz = inset.paragraph()->size();
- for (Paragraph::size_type i = 0; i != siz; ++i) {
- char c = inset.paragraph()->getChar(i);
- switch (c) {
- case Paragraph::META_NEWLINE:
+ pos_type siz = par->size();
+ for (pos_type i = 0; i < siz; ++i) {
+ // ignore all struck out text
+ if (isDeletedText(*par, i))
+ continue;
+
+ if (par->isNewline(i)) {
os << '\n';
- break;
- default:
- os << c;
- break;
+ ++lines;
+ } else {
+ os << par->getChar(i);
}
}
par = par->next();
+ if (par) {
+ os << "\n\n";
+ lines += 2;
+ }
}
-
- return 1;
+
+ return lines;
}
-int InsetERT::ascii(Buffer const *,
- std::ostream &, int /*linelen*/) const
+int InsetERT::ascii(Buffer const *, ostream &, int /*linelen*/) const
{
return 0;
}
-int InsetERT::linuxdoc(Buffer const *, std::ostream &) const
+int InsetERT::linuxdoc(Buffer const *, ostream & os) const
{
- return 0;
+ Paragraph * par = inset.paragraph();
+ int lines = 0;
+ while (par) {
+ pos_type siz = par->size();
+ for (pos_type i = 0; i < siz; ++i) {
+ if (par->isNewline(i)) {
+ os << '\n';
+ ++lines;
+ } else {
+ os << par->getChar(i);
+ }
+ }
+ par = par->next();
+ if (par) {
+ os << "\n";
+ lines ++;
+ }
+ }
+
+ return lines;
}
-int InsetERT::docBook(Buffer const *, std::ostream &) const
+int InsetERT::docbook(Buffer const *, ostream & os, bool) const
{
- return 0;
+ Paragraph * par = inset.paragraph();
+ int lines = 0;
+ while (par) {
+ pos_type siz = par->size();
+ for (pos_type i = 0; i < siz; ++i) {
+ if (par->isNewline(i)) {
+ os << '\n';
+ ++lines;
+ } else {
+ os << par->getChar(i);
+ }
+ }
+ par = par->next();
+ if (par) {
+ os << "\n";
+ lines ++;
+ }
+ }
+
+ return lines;
}
-UpdatableInset::RESULT
-InsetERT::localDispatch(BufferView * bv, kb_action action, string const & arg)
+Inset::RESULT InsetERT::localDispatch(FuncRequest const & cmd)
{
- UpdatableInset::RESULT result = DISPATCHED_NOUPDATE;
+ Inset::RESULT result = UNDISPATCHED;
+ BufferView * bv = cmd.view();
- if (!inset.paragraph()->size()) {
+ if (inset.paragraph()->empty()) {
set_latex_font(bv);
}
- switch(action) {
+ switch (cmd.action) {
+ case LFUN_INSET_MODIFY: {
+ InsetERT::ERTStatus status_;
+ InsetERTMailer::string2params(cmd.argument, status_);
+
+ status(bv, status_);
+
+ /* FIXME: I refuse to believe we have to live
+ * with ugliness like this ! Note that this
+ * rebreak *is* needed. Consider a change from
+ * Open (needfullrow) to Inlined (only the space
+ * taken by the text).
+ */
+ LyXText * t = inset.getLyXText(cmd.view());
+ t->need_break_row = t->rows().begin();
+ t->fullRebreak();
+ t->setCursorIntern(t->cursor.par(), t->cursor.pos());
+ inset.update(cmd.view(), true);
+ bv->updateInset(this);
+ result = DISPATCHED;
+ }
+ break;
+
+ case LFUN_MOUSE_PRESS:
+ lfunMousePress(cmd);
+ result = DISPATCHED;
+ break;
+
+ case LFUN_MOUSE_MOTION:
+ lfunMouseMotion(cmd);
+ result = DISPATCHED;
+ break;
+
+ case LFUN_MOUSE_RELEASE:
+ lfunMouseRelease(cmd);
+ result = DISPATCHED;
+ break;
+
case LFUN_LAYOUT:
- bv->owner()->setLayout(inset.paragraph()->getLayout());
+ bv->owner()->setLayout(inset.paragraph()->layout()->name());
+ result = DISPATCHED_NOUPDATE;
break;
+
default:
- result = InsetCollapsable::localDispatch(bv, action, arg);
+ result = InsetCollapsable::localDispatch(cmd);
}
- switch(action) {
+
+ switch (cmd.action) {
case LFUN_BREAKPARAGRAPH:
case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
+ case LFUN_BACKSPACE:
+ case LFUN_BACKSPACE_SKIP:
+ case LFUN_DELETE:
+ case LFUN_DELETE_SKIP:
+ case LFUN_DELETE_LINE_FORWARD:
+ case LFUN_CUT:
set_latex_font(bv);
break;
-
+
default:
break;
}
string const InsetERT::get_new_label() const
{
string la;
- Paragraph::size_type const max_length = 15;
-
- Paragraph::size_type const p_siz = inset.paragraph()->size();
- Paragraph::size_type const n = std::min(max_length, p_siz);
- int i = 0;
- int j = 0;
+ pos_type const max_length = 15;
+ pos_type const p_siz = inset.paragraph()->size();
+ pos_type const n = min(max_length, p_siz);
+ pos_type i = 0;
+ pos_type j = 0;
for(; i < n && j < p_siz; ++j) {
if (inset.paragraph()->isInset(j))
continue;
la += inset.paragraph()->getChar(j);
++i;
}
- if (i > 0 && j < p_siz) {
+ if (inset.paragraph()->next() || (i > 0 && j < p_siz)) {
la += "...";
}
if (la.empty()) {
}
-bool InsetERT::checkInsertChar(LyXFont & font)
+bool InsetERT::checkInsertChar(LyXFont & /* font */)
{
- LyXFont f(LyXFont::ALL_INHERIT);
+#ifdef SET_HARD_FONT
+ LyXFont f(LyXFont::ALL_INHERIT, latex_language);
font = f;
font.setFamily(LyXFont::TYPEWRITER_FAMILY);
font.setColor(LColor::latex);
+#endif
return true;
}
}
-void InsetERT::draw(BufferView * bv, LyXFont const & f,
- int baseline, float & x, bool cleared) const
+void InsetERT::draw(BufferView * bv, LyXFont const & f,
+ int baseline, float & x) const
{
- Painter & pain = bv->painter();
-
- button_length = width_collapsed();
- button_top_y = -ascent(bv, f);
- button_bottom_y = -ascent(bv, f) + ascent_collapsed() +
- descent_collapsed();
-
- if (!isOpen()) {
- draw_collapsed(pain, baseline, x);
- x += TEXT_TO_INSET_OFFSET;
- return;
- }
-
- float old_x = x;
-
- if (!owner())
- x += static_cast<float>(scroll());
-
- if (!cleared && (inset.need_update == InsetText::FULL ||
- inset.need_update == InsetText::INIT ||
- top_x != int(x) ||
- top_baseline != baseline))
- {
- // we don't need anymore to clear here we just have to tell
- // the underlying LyXText that it should do the RowClear!
- inset.setUpdateStatus(bv, InsetText::FULL);
- bv->text->status(bv, LyXText::CHANGED_IN_DRAW);
- return;
- }
-
- top_x = int(x);
- topx_set = true;
- top_baseline = baseline;
-
- int const bl = baseline - ascent(bv, f) + ascent_collapsed();
-
- if (inlined()) {
- inset.draw(bv, f, baseline, x, cleared);
- } else {
- draw_collapsed(pain, bl, old_x);
- inset.draw(bv, f,
- bl + descent_collapsed() + inset.ascent(bv, f),
- x, cleared);
- }
- need_update = NONE;
+ InsetCollapsable::draw(bv, f, baseline, x, inlined());
}
-void InsetERT::set_latex_font(BufferView * bv)
+void InsetERT::set_latex_font(BufferView * /* bv */)
{
- LyXFont font(LyXFont::ALL_INHERIT);
+#ifdef SET_HARD_FONT
+ LyXFont font(LyXFont::ALL_INHERIT, latex_language);
font.setFamily(LyXFont::TYPEWRITER_FAMILY);
font.setColor(LColor::latex);
+
inset.getLyXText(bv)->setFont(bv, font, false);
+#endif
}
+// attention this function can be called with bv == 0
void InsetERT::status(BufferView * bv, ERTStatus const st) const
{
if (st != status_) {
status_ = st;
- switch(st) {
+ switch (st) {
case Inlined:
- inset.setAutoBreakRows(false);
+ if (bv)
+ inset.setUpdateStatus(bv, InsetText::INIT);
break;
case Open:
- inset.setAutoBreakRows(true);
collapsed_ = false;
- need_update = FULL;
setButtonLabel();
break;
case Collapsed:
- inset.setAutoBreakRows(true);
collapsed_ = true;
- need_update = FULL;
setButtonLabel();
if (bv)
bv->unlockInset(const_cast<InsetERT *>(this));
break;
}
- if (bv)
- bv->updateInset(const_cast<InsetERT *>(this), true);
+ if (bv) {
+ bv->updateInset(const_cast<InsetERT *>(this));
+ bv->buffer()->markDirty();
+ }
}
}
bool InsetERT::showInsetDialog(BufferView * bv) const
{
- bv->owner()->getDialogs()->showERT(const_cast<InsetERT *>(this));
+ InsetERTMailer mailer(const_cast<InsetERT &>(*this));
+ mailer.showDialog(bv);
return true;
}
void InsetERT::close(BufferView * bv) const
{
- if (collapsed_)
+ if (status_ == Collapsed || status_ == Inlined)
return;
+
status(bv, Collapsed);
}
+
+
+WordLangTuple const
+InsetERT::selectNextWordToSpellcheck(BufferView * bv, float &) const
+{
+ bv->unlockInset(const_cast<InsetERT *>(this));
+ return WordLangTuple();
+}
+
+
+void InsetERT::getDrawFont(LyXFont & font) const
+{
+ LyXFont f(LyXFont::ALL_INHERIT, latex_language);
+ font = f;
+ font.setFamily(LyXFont::TYPEWRITER_FAMILY);
+ font.setColor(LColor::latex);
+}
+
+
+int InsetERT::getMaxWidth(BufferView * bv, UpdatableInset const * in) const
+{
+ int w = InsetCollapsable::getMaxWidth(bv, in);
+ if (status_ != Inlined || w < 0)
+ return w;
+ LyXText * text = inset.getLyXText(bv);
+ int rw = text->rows().begin()->width();
+ if (!rw)
+ rw = w;
+ rw += 40;
+ if (text->rows().size() == 1 && rw < w)
+ return -1;
+ return w;
+}
+
+
+void InsetERT::update(BufferView * bv, bool reinit)
+{
+ if (inset.need_update & InsetText::INIT ||
+ inset.need_update & InsetText::FULL) {
+ setButtonLabel();
+ }
+
+ InsetCollapsable::update(bv, reinit);
+}
+
+
+string const InsetERTMailer::name_("ert");
+
+InsetERTMailer::InsetERTMailer(InsetERT & inset)
+ : inset_(inset)
+{}
+
+
+string const InsetERTMailer::inset2string() const
+{
+ return params2string(inset_.status());
+}
+
+
+void InsetERTMailer::string2params(string const & in,
+ InsetERT::ERTStatus & status)
+{
+ status = InsetERT::Collapsed;
+
+ string name;
+ string body = split(in, name, ' ');
+
+ if (body.empty())
+ return;
+
+ status = static_cast<InsetERT::ERTStatus>(strToInt(body));
+}
+
+
+string const
+InsetERTMailer::params2string(InsetERT::ERTStatus status)
+{
+ return name_ + ' ' + tostr(status);
+}
projects / lyx.git / blobdiff