#include "insetert.h"
#include "gettext.h"
#include "lyxfont.h"
+#include "language.h"
#include "buffer.h"
-#include "insets/insettext.h"
-#include "support/LOstream.h"
#include "lyx_gui_misc.h"
#include "BufferView.h"
#include "LyXView.h"
#include "lyxtext.h"
-#include "frontends/Dialogs.h"
#include "debug.h"
+#include "lyxtextclasslist.h"
+
+#include "insets/insettext.h"
+
+#include "frontends/Dialogs.h"
+#include "frontends/Alert.h"
+
+#include "support/LOstream.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");
-
}
font.setColor(LColor::latex);
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);
}
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);
+
+#ifndef INHERIT_LANG
+ LyXFont font(LyXFont::ALL_INHERIT, latex_language);
+#else
+ LyXFont font(LyXFont::ALL_INHERIT);
+#endif
+
+ 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();
+ }
+
if (!token_found) {
if (collapsed_) {
status(0, Collapsed);
{
string st;
- switch(status_) {
+ switch (status_) {
case Open:
st = "Open";
break;
os << getInsetName() << "\n"
<< "status "<< st << "\n";
- inset.writeParagraphData(buf, os);
+ //inset.writeParagraphData(buf, os);
+ string const layout =
+ textclasslist.NameOfLayout(buf->params.textclass, 0);
+ 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:
+ case Paragraph::META_HFILL:
+ lyxerr << "Element is not allowed in insertERT"
+ << endl;
+ case Paragraph::META_NEWLINE:
+ os << "\n\\newline \n";
+ break;
+ case '\\':
+ os << "\n\\backslash \n";
+ break;
+ default:
+ os << c;
+ break;
+ }
+ }
+ par = par->next();
+ }
}
// if selectall is activated then the fontchange was an outside general
// fontchange and this messages is not needed
if (!selectall)
- WriteAlert(_("Impossible Operation!"),
+ Alert::alert(_("Impossible Operation!"),
_("Not permitted to change font-types inside ERT-insets!"),
_("Sorry."));
}
+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, unsigned int button)
{
- InsetCollapsable::edit(bv, x, y, button);
+ if (button == 3)
+ 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::insetButtonPress(BufferView * bv,
+ int x, int y, int button)
+{
+ if (status_ == Inlined) {
+ inset.insetButtonPress(bv, x, y, button);
+ } else {
+ InsetCollapsable::insetButtonPress(bv, x, y, button);
+ }
+}
+
+
+bool InsetERT::insetButtonRelease(BufferView * bv, int x, int y, int button)
{
if (button == 3) {
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 && (x >= 0) && (x < button_length) &&
+ (y >= button_top_y) && (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);
+ int yy = ascent(bv, font) + y - inset.ascent(bv, font);
+
+ // inlined is special - the text appears above
+ // button_bottom_y
+ if (status_ == Inlined) {
+ inset.insetButtonRelease(bv, x, yy, button);
+ } else if (!collapsed_ && (y > button_bottom_y)) {
+ yy -= (ascent_collapsed() + descent_collapsed());
+ inset.insetButtonRelease(bv, x, yy, button);
+ }
+ }
+ return false;
+}
+
+
+void InsetERT::insetMotionNotify(BufferView * bv,
+ int x, int y, int state)
+{
+ if (status_ == Inlined) {
+ inset.insetMotionNotify(bv, x, y, state);
+ } else {
+ InsetCollapsable::insetMotionNotify(bv, x, y, state);
}
}
-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);
+ 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_NEWLINE:
os << '\n';
+ ++lines;
break;
default:
os << c;
}
}
par = par->next();
+ if (par) {
+ os << "\n\n";
+ lines += 2;
+ }
}
- return 1;
+ return lines;
}
int InsetERT::ascii(Buffer const *,
- std::ostream &, int /*linelen*/) 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) {
+ Paragraph::value_type c = par->getChar(i);
+ switch (c) {
+ case Paragraph::META_NEWLINE:
+ os << '\n';
+ ++lines;
+ break;
+ default:
+ os << c;
+ break;
+ }
+ }
+ 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) 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) {
+ Paragraph::value_type c = par->getChar(i);
+ switch (c) {
+ case Paragraph::META_NEWLINE:
+ os << '\n';
+ ++lines;
+ break;
+ default:
+ os << c;
+ break;
+ }
+ }
+ par = par->next();
+ if (par) {
+ os << "\n";
+ lines ++;
+ }
+ }
+
+ return lines;
}
set_latex_font(bv);
}
- switch(action) {
+ switch (action) {
case LFUN_LAYOUT:
bv->owner()->setLayout(inset.paragraph()->getLayout());
break;
default:
result = InsetCollapsable::localDispatch(bv, action, arg);
}
- switch(action) {
+ switch (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;
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);
+ pos_type const max_length = 15;
+ pos_type const p_siz = inset.paragraph()->size();
+ pos_type const n = min(max_length, p_siz);
int i = 0;
int j = 0;
for(; i < n && j < p_siz; ++j) {
{
if (st != status_) {
status_ = st;
- switch(st) {
+ switch (st) {
case Inlined:
inset.setAutoBreakRows(false);
break;
break;
}
if (bv)
- bv->updateInset(const_cast<InsetERT *>(this), true);
+ bv->updateInset(const_cast<InsetERT *>(this), false);
}
}
return;
status(bv, Collapsed);
}
+
+
+string const InsetERT::selectNextWordToSpellcheck(BufferView * bv,float &) const
+{
+ bv->unlockInset(const_cast<InsetERT *>(this));
+ return string();
+}
projects / lyx.git / blobdiff