X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fformulabase.C;h=3d36585989575072d4ee786e6855e1b72dfc94e3;hb=cf629f43316e5f20f97128a10ea14e0b4215b056;hp=946541d850df7d4bfd171a522328fa9a871dcfec;hpb=c06a45c6e4b7c3724f003561c5f9fc2e024aa549;p=lyx.git diff --git a/src/mathed/formulabase.C b/src/mathed/formulabase.C index 946541d850..3d36585989 100644 --- a/src/mathed/formulabase.C +++ b/src/mathed/formulabase.C @@ -1,9 +1,8 @@ - /* -* File: formula.C -* Purpose: Implementation of formula inset +/* +* File: formulabase.C +* Purpose: Implementation of common parts of the LyX math insets * Author: Alejandro Aguilar Sierra * Created: January 1996 -* Description: Allows the edition of math paragraphs inside Lyx. * * Copyright: 1996-1998 Alejandro Aguilar Sierra * @@ -17,6 +16,7 @@ #include #include "Lsstream.h" +#include "support/LAssert.h" #ifdef __GNUG__ #pragma implementation @@ -26,30 +26,28 @@ #include "formulamacro.h" #include "commandtags.h" #include "math_cursor.h" -#include "math_parser.h" #include "BufferView.h" #include "lyxtext.h" #include "lyxfunc.h" #include "gettext.h" #include "LaTeXFeatures.h" #include "debug.h" -#include "support/LOstream.h" +#include "support.h" +#include "support/lstrings.h" #include "LyXView.h" #include "Painter.h" #include "font.h" #include "math_arrayinset.h" #include "math_spaceinset.h" +#include "math_macrotable.h" +#include "math_factory.h" #include "support/lyxlib.h" -#include "mathed/support.h" #include "undo_funcs.h" using std::endl; using std::ostream; using std::vector; -extern char const * latex_special_chars; - -int greek_kb_flag = 0; extern char const * latex_mathenv[]; MathCursor * mathcursor = 0; @@ -62,32 +60,21 @@ int sel_x; int sel_y; bool sel_flag; -void mathed_init_fonts(); - -string nicelabel(string const & label) -{ - return "(" + (label.empty() ? "#" : label) + ")"; -} - void handleFont(BufferView * bv, MathTextCodes t) { - if (mathcursor->Selection()) + if (mathcursor->selection()) bv->lockedInsetStoreUndo(Undo::EDIT); mathcursor->handleFont(t); } -void handleAccent(BufferView * bv, string const & name, int code) -{ - bv->lockedInsetStoreUndo(Undo::EDIT); - mathcursor->handleAccent(name, code); -} -void handleDelim(BufferView * bv, int l, int r) +void handleAccent(BufferView * bv, string const & name) { bv->lockedInsetStoreUndo(Undo::EDIT); - mathcursor->handleDelim(l, r); + mathcursor->insert(createMathInset(name)); } + bool openNewInset(BufferView * bv, UpdatableInset * new_inset) { LyXText * lt = bv->getLyXText(); @@ -103,80 +90,42 @@ bool openNewInset(BufferView * bv, UpdatableInset * new_inset) } -} // namespaces - - - -namespace { - - -// returns the nearest enclosing matrix -MathArrayInset * matrixpar(int & idx) +// returns the nearest enclosing grid +MathArrayInset * matrixpar(MathInset::idx_type & idx) { idx = 0; - return - static_cast - (mathcursor ? mathcursor->enclosing(LM_OT_MATRIX, idx) : 0); + return mathcursor ? mathcursor->enclosingArray(idx) : 0; } } // namespace anon -InsetFormulaBase::InsetFormulaBase(MathInset * par) - : par_(par) -{} - - -InsetFormulaBase::InsetFormulaBase(InsetFormulaBase const & f) - : UpdatableInset(f), par_(static_cast(f.par_->clone())) -{} - - -InsetFormulaBase::~InsetFormulaBase() -{ - delete par_; -} - -void InsetFormulaBase::read(Buffer const *, LyXLex & lex) +InsetFormulaBase::InsetFormulaBase() + : view_(0), font_(), xo_(0), yo_(0) { - read(lex); + // This is needed as long the math parser is not re-entrant + MathMacroTable::builtinMacros(); + //lyxerr << "sizeof MathInset: " << sizeof(MathInset) << "\n"; } -void InsetFormulaBase::write(Buffer const *, ostream & os) const -{ - write(os); -} - -int InsetFormulaBase::latex(Buffer const *, ostream & os, - bool fragile, bool spacing) const -{ - return latex(os, fragile, spacing); -} -int InsetFormulaBase::ascii(Buffer const *, ostream & os, int spacing) const -{ - return ascii(os, spacing); -} +// Check if uses AMS macros +void InsetFormulaBase::validate(LaTeXFeatures &) const +{} -int InsetFormulaBase::linuxdoc(Buffer const *, ostream & os) const -{ - return linuxdoc(os); -} -int InsetFormulaBase::docBook(Buffer const *, ostream & os) const +void InsetFormulaBase::metrics(BufferView * bv, LyXFont const & f) const { - return docBook(os); + if (bv) + view_ = bv; + font_ = f; + MathMetricsInfo mi(view_, font_, display() ? LM_ST_DISPLAY : LM_ST_TEXT); + par()->metrics(mi); } - -// Check if uses AMS macros -void InsetFormulaBase::validate(LaTeXFeatures &) const -{} - - string const InsetFormulaBase::editMessage() const { return _("Math editor mode"); @@ -185,17 +134,14 @@ string const InsetFormulaBase::editMessage() const void InsetFormulaBase::edit(BufferView * bv, int x, int /*y*/, unsigned int) { - mathcursor = new MathCursor(this); - if (!bv->lockInset(this)) lyxerr[Debug::MATHED] << "Cannot lock inset!!!" << endl; - Metrics(); - //bv->updateInset(this, false); - if (x == 0) - mathcursor->first(); - else - mathcursor->last(); + mathcursor = new MathCursor(this, x == 0); + metrics(bv); + // if that is removed, we won't get the magenta box when entering an + // inset for the first time + bv->updateInset(this, false); sel_x = 0; sel_y = 0; sel_flag = false; @@ -204,7 +150,7 @@ void InsetFormulaBase::edit(BufferView * bv, int x, int /*y*/, unsigned int) void InsetFormulaBase::edit(BufferView * bv, bool front) { -#warning Please have a look if this is right (Jug) + // looks hackish but seems to work edit(bv, front ? 0 : 1, 0, 0); } @@ -212,8 +158,8 @@ void InsetFormulaBase::edit(BufferView * bv, bool front) void InsetFormulaBase::insetUnlock(BufferView * bv) { if (mathcursor) { - if (mathcursor->InMacroMode()) { - mathcursor->MacroModeClose(); + if (mathcursor->inMacroMode()) { + mathcursor->macroModeClose(); updateLocal(bv, true); } delete mathcursor; @@ -225,9 +171,10 @@ void InsetFormulaBase::insetUnlock(BufferView * bv) void InsetFormulaBase::getCursorPos(BufferView *, int & x, int & y) const { - mathcursor->GetPos(x, y); - x -= par_->xo(); - y -= par_->yo(); + mathcursor->getPos(x, y); + x += xo_; + y += yo_ - 3; + //lyxerr << "getCursorPos: " << x << " " << y << "\n"; } @@ -239,15 +186,18 @@ void InsetFormulaBase::toggleInsetCursor(BufferView * bv) if (isCursorVisible()) bv->hideLockedInsetCursor(); else { + metrics(bv); int x; int y; - mathcursor->GetPos(x, y); - //x -= par_->xo(); - y -= par_->yo(); - int asc; - int desc; - math_font_max_dim(LM_TC_TEXTRM, LM_ST_TEXT, asc, desc); - bv->showLockedInsetCursor(x, y, asc, desc); + mathcursor->getPos(x, y); + y -= 3; + y -= yo_; + int asc = 0; + int des = 0; + MathMetricsInfo mi(bv, font_, LM_ST_TEXT); + math_font_max_dim(LM_TC_TEXTRM, mi, asc, des); + bv->showLockedInsetCursor(x, y, asc, des); + //lyxerr << "toggleInsetCursor: " << x << " " << y << "\n"; } toggleCursorVisible(); @@ -260,13 +210,14 @@ void InsetFormulaBase::showInsetCursor(BufferView * bv, bool) if (mathcursor) { int x; int y; - mathcursor->GetPos(x, y); - x -= par_->xo(); - y -= par_->yo(); - int asc; - int desc; - math_font_max_dim(LM_TC_TEXTRM, LM_ST_TEXT, asc, desc); - bv->fitLockedInsetCursor(x, y, asc, desc); + mathcursor->getPos(x, y); + int asc = 0; + int des = 0; + MathMetricsInfo mi(bv, font_, LM_ST_TEXT); + math_font_max_dim(LM_TC_TEXTRM, mi, asc, des); + //bv->fitLockedInsetCursor(x, y, asc, des); + //metrics(bv); + //lyxerr << "showInsetCursor: " << x << " " << y << "\n"; } toggleInsetCursor(bv); } @@ -295,25 +246,18 @@ vector const InsetFormulaBase::getLabelList() const void InsetFormulaBase::updateLocal(BufferView * bv, bool dirty) { - Metrics(); + metrics(bv); bv->updateInset(this, dirty); } -void InsetFormulaBase::Metrics() const -{ - const_cast(par_)->Metrics(LM_ST_TEXT); -} - - void InsetFormulaBase::insetButtonRelease(BufferView * bv, int x, int y, int /*button*/) { if (mathcursor) { hideInsetCursor(bv); - x += par_->xo(); - y += par_->yo(); - mathcursor->SetPos(x, y); + mathcursor->setPos(x + xo_, y + yo_); + //lyxerr << "insetButtonRelease: " << x + xo_ << " " << y + yo_ << "\n"; showInsetCursor(bv); if (sel_flag) { sel_flag = false; @@ -331,8 +275,8 @@ void InsetFormulaBase::insetButtonPress(BufferView * bv, sel_flag = false; sel_x = x; sel_y = y; - if (mathcursor && mathcursor->Selection()) { - mathcursor->SelClear(); + if (mathcursor && mathcursor->selection()) { + mathcursor->selClear(); bv->updateInset(this, false); } } @@ -344,17 +288,15 @@ void InsetFormulaBase::insetMotionNotify(BufferView * bv, if (sel_x && sel_y && abs(x-sel_x) > 4 && !sel_flag) { sel_flag = true; hideInsetCursor(bv); - mathcursor->SetPos(sel_x + par_->xo(), sel_y + par_->yo()); - mathcursor->SelStart(); + mathcursor->setPos(sel_x, sel_y); + mathcursor->selStart(); showInsetCursor(bv); - mathcursor->GetPos(sel_x, sel_y); + mathcursor->getPos(sel_x, sel_y); } else if (sel_flag) { hideInsetCursor(bv); - x += par_->xo(); - y += par_->yo(); - mathcursor->SetPos(x, y); + mathcursor->setPos(x, y); showInsetCursor(bv); - mathcursor->GetPos(x, y); + mathcursor->getPos(x, y); if (sel_x != x || sel_y != y) bv->updateInset(this, false); sel_x = x; @@ -365,32 +307,31 @@ void InsetFormulaBase::insetMotionNotify(BufferView * bv, void InsetFormulaBase::insetKeyPress(XKeyEvent *) { - lyxerr[Debug::MATHED] - << "Used InsetFormulaBase::InsetKeyPress." << endl; + lyxerr[Debug::MATHED] << "Used InsetFormulaBase::InsetKeyPress." << endl; } - UpdatableInset::RESULT InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, string const & arg) { - //lyxerr << "InsetFormulaBase::LocalDispatch: act: " << action + //lyxerr << "InsetFormulaBase::localDispatch: act: " << action // << " arg: '" << arg << "' cursor: " << mathcursor << "\n"; if (!mathcursor) return UNDISPATCHED; - MathTextCodes varcode = LM_TC_MIN; - bool was_macro = mathcursor->InMacroMode(); - bool sel = false; - bool was_selection = mathcursor->Selection(); - RESULT result = DISPATCHED; + if (mathcursor->asHyperActiveInset()) { + lyxerr << " uurr.... getting dificult now\n"; + return mathcursor->asHyperActiveInset()->localDispatch(bv, action, arg); + } - hideInsetCursor(bv); + RESULT result = DISPATCHED; + bool sel = false; + bool was_macro = mathcursor->inMacroMode(); + bool was_selection = mathcursor->selection(); - if (mathcursor->getLastCode() == LM_TC_TEX) - varcode = LM_TC_TEX; + hideInsetCursor(bv); mathcursor->normalize(); @@ -402,7 +343,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, sel = true; // fall through... case LFUN_RIGHT: - result = DISPATCH_RESULT(mathcursor->Right(sel)); + result = mathcursor->right(sel) ? DISPATCHED : FINISHED_RIGHT; updateLocal(bv, false); break; @@ -411,7 +352,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, sel = true; // fall through case LFUN_LEFT: - result = DISPATCH_RESULT(mathcursor->Left(sel)); + result = mathcursor->left(sel) ? DISPATCHED : FINISHED; updateLocal(bv, false); break; @@ -420,7 +361,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, sel = true; case LFUN_UP: - result = DISPATCH_RESULT(mathcursor->Up(sel)); + result = mathcursor->up(sel) ? DISPATCHED : FINISHED_UP; updateLocal(bv, false); break; @@ -429,23 +370,29 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, sel = true; case LFUN_DOWN: - result = DISPATCH_RESULT(mathcursor->Down(sel)); + result = mathcursor->down(sel) ? DISPATCHED : FINISHED_DOWN; updateLocal(bv, false); break; + case LFUN_HOMESEL: + sel = true; + case LFUN_HOME: - mathcursor->Home(); + mathcursor->home(sel); updateLocal(bv, false); break; + case LFUN_ENDSEL: + sel = true; + case LFUN_END: - mathcursor->End(); + mathcursor->end(sel); updateLocal(bv, false); break; case LFUN_DELETE_LINE_FORWARD: bv->lockedInsetStoreUndo(Undo::DELETE); - mathcursor->DelLine(); + mathcursor->delLine(); updateLocal(bv, true); break; @@ -465,26 +412,17 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, updateLocal(bv, true); break; + case LFUN_DELETE_WORD_BACKWARD: case LFUN_BACKSPACE: - // if (!mathcursor->InMacroMode() && mathcursor->pos() == 0) - if (mathcursor->pos() == 0) { - bv->lockedInsetStoreUndo(Undo::DELETE); - mathcursor->pullArg(false); - bv->updateInset(this, true); - break; - } - if (mathcursor->InMacroMode()) - mathcursor->Left(); - else - mathcursor->plainLeft(); - // fall through... + bv->lockedInsetStoreUndo(Undo::DELETE); + mathcursor->backspace(); + bv->updateInset(this, true); + break; + case LFUN_DELETE_WORD_FORWARD: case LFUN_DELETE: bv->lockedInsetStoreUndo(Undo::DELETE); - if (mathcursor->pos() == mathcursor->array().size()) - mathcursor->pullArg(true); - else - mathcursor->Delete(); + mathcursor->erase(); bv->updateInset(this, true); break; @@ -492,100 +430,73 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, // sprintf(dispatch_buffer, "%d %d",); // dispatch_result = dispatch_buffer; // break; - case LFUN_SETXY: - { + case LFUN_SETXY: { lyxerr << "LFUN_SETXY broken!\n"; - int x; - int y; - int x1; - int y1; + int x = 0; + int y = 0; istringstream is(arg.c_str()); is >> x >> y; - par_->GetXY(x1, y1); - mathcursor->SetPos(x1 + x, y1 + y); + mathcursor->setPos(x, y); updateLocal(bv, false); + break; } - break; - - // cursor selection ---------------------------- case LFUN_PASTE: if (was_macro) - mathcursor->MacroModeClose(); + mathcursor->macroModeClose(); bv->lockedInsetStoreUndo(Undo::INSERT); - mathcursor->SelPaste(); + mathcursor->selPaste(); updateLocal(bv, true); break; case LFUN_CUT: bv->lockedInsetStoreUndo(Undo::DELETE); - mathcursor->SelCut(); + mathcursor->selCut(); updateLocal(bv, true); break; case LFUN_COPY: - mathcursor->SelCopy(); + mathcursor->selCopy(); break; - case LFUN_HOMESEL: - case LFUN_ENDSEL: case LFUN_WORDRIGHTSEL: case LFUN_WORDLEFTSEL: break; // --- accented characters ------------------------------ - case LFUN_UMLAUT: handleAccent(bv, "ddot", LM_ddot); break; - case LFUN_CIRCUMFLEX: handleAccent(bv, "hat", LM_hat); break; - case LFUN_GRAVE: handleAccent(bv, "grave", LM_grave); break; - case LFUN_ACUTE: handleAccent(bv, "acute", LM_acute); break; - case LFUN_TILDE: handleAccent(bv, "tilde", LM_tilde); break; - case LFUN_MACRON: handleAccent(bv, "bar", LM_bar); break; - case LFUN_DOT: handleAccent(bv, "dot", LM_dot); break; - case LFUN_CARON: handleAccent(bv, "check", LM_check); break; - case LFUN_BREVE: handleAccent(bv, "breve", LM_breve); break; - case LFUN_VECTOR: handleAccent(bv, "vec", LM_vec); break; - - // Greek mode - case LFUN_GREEK: - if (!greek_kb_flag) { - greek_kb_flag = 1; - bv->owner()->message(_("Math greek mode on")); - } else - greek_kb_flag = 0; - break; - - // Greek keyboard - case LFUN_GREEK_TOGGLE: - greek_kb_flag = greek_kb_flag ? 0 : 2; - if (greek_kb_flag) - bv->owner()->message(_("Math greek keyboard on")); - else - bv->owner()->message(_("Math greek keyboard off")); + case LFUN_UMLAUT: handleAccent(bv, "ddot"); break; + case LFUN_CIRCUMFLEX: handleAccent(bv, "hat"); break; + case LFUN_GRAVE: handleAccent(bv, "grave"); break; + case LFUN_ACUTE: handleAccent(bv, "acute"); break; + case LFUN_TILDE: handleAccent(bv, "tilde"); break; + case LFUN_MACRON: handleAccent(bv, "bar"); break; + case LFUN_DOT: handleAccent(bv, "dot"); break; + case LFUN_CARON: handleAccent(bv, "check"); break; + case LFUN_BREVE: handleAccent(bv, "breve"); break; + case LFUN_VECTOR: handleAccent(bv, "vec"); break; + + // Math fonts + case LFUN_GREEK_TOGGLE: handleFont(bv, LM_TC_GREEK); break; + case LFUN_BOLD: handleFont(bv, LM_TC_BF); break; + case LFUN_SANS: handleFont(bv, LM_TC_SF); break; + case LFUN_EMPH: handleFont(bv, LM_TC_CAL); break; + case LFUN_ROMAN: handleFont(bv, LM_TC_RM); break; + case LFUN_CODE: handleFont(bv, LM_TC_TT); break; + case LFUN_NOUN: handleFont(bv, LM_TC_BB); break; + case LFUN_DEFAULT: handleFont(bv, LM_TC_VAR); break; + + case LFUN_GREEK: + handleFont(bv, LM_TC_GREEK1); + if (arg.size()) + mathcursor->interpret(arg); break; - // Math fonts - case LFUN_BOLD: handleFont(bv, LM_TC_BF); break; - case LFUN_SANS: handleFont(bv, LM_TC_SF); break; - case LFUN_EMPH: handleFont(bv, LM_TC_CAL); break; - case LFUN_ROMAN: handleFont(bv, LM_TC_RM); break; - case LFUN_CODE: handleFont(bv, LM_TC_TT); break; - case LFUN_DEFAULT: handleFont(bv, LM_TC_VAR); break; - case LFUN_MATH_MODE: handleFont(bv, LM_TC_TEXTRM); //bv->owner()->message(_("math text mode toggled")); break; -#ifndef NO_LATEX - case LFUN_TEX: - if (!mathcursor->Selection()) { - mathcursor->handleFont(LM_TC_TEX); - //bv->owner()->message(_("TeX mode toggled")); - } - break; -#endif - case LFUN_MATH_LIMITS: bv->lockedInsetStoreUndo(Undo::INSERT); if (mathcursor->toggleLimits()) @@ -593,79 +504,53 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, break; case LFUN_MATH_SIZE: +#if 0 if (!arg.empty()) { bv->lockedInsetStoreUndo(Undo::INSERT); - latexkeys const * l = in_word_set(arg); - mathcursor->SetSize(MathStyles(l ? l->id : static_cast(-1))); + mathcursor->setSize(arg); updateLocal(bv, true); } +#endif break; case LFUN_INSERT_MATRIX: if (!arg.empty()) { bv->lockedInsetStoreUndo(Undo::INSERT); - mathcursor->Interpret("matrix " + arg); + mathcursor->interpret("matrix " + arg); updateLocal(bv, true); } break; - case LFUN_INSERT_MATH: - if (!arg.empty()) { - bv->lockedInsetStoreUndo(Undo::INSERT); - mathcursor->Interpret(arg); - updateLocal(bv, true); - } + case LFUN_MATH_SPACE: + { + bv->lockedInsetStoreUndo(Undo::EDIT); + mathcursor->insert(MathAtom(new MathSpaceInset(1))); + updateLocal(bv, true); break; + } case LFUN_MATH_DELIM: { bv->lockedInsetStoreUndo(Undo::INSERT); - static const string vdelim("(){}[]./|"); //lyxerr << "formulabase::LFUN_MATH_DELIM, arg: '" << arg << "'\n"; - - if (arg.empty()) - break; - - // try to read integers first - int ilt = '('; - int irt = '.'; + string ls; + string rs; istringstream is(arg.c_str()); - is >> ilt >> irt; - - if (!is) { // ok, the beasties are no integers... try something else - ilt = '('; - irt = '.'; - - istringstream is(arg.c_str()); - string lt; - string rt; - is >> lt >> rt; - //lyxerr << "formulabase::LFUN_MATH_DELIM, lt: '" << lt << "'\n"; - //lyxerr << "formulabase::LFUN_MATH_DELIM, rt: '" << rt << "'\n"; - - if (lt.size() > 1) { - latexkeys const * l = in_word_set(lt); - if (l) - ilt = l->id; - } else if (vdelim.find(lt[0]) != string::npos) - ilt = lt[0]; - - if (rt.size() > 1) { - latexkeys const * l = in_word_set(rt); - if (l) - irt = l->id; - } else if (vdelim.find(rt[0]) != string::npos) - irt = rt[0]; + is >> ls >> rs; + if (!is) { + lyxerr << "can't parse delimeters from '" << arg << "'\n"; + break; } - - handleDelim(bv, ilt, irt); + bv->lockedInsetStoreUndo(Undo::EDIT); + mathcursor->handleDelim(ls, rs); updateLocal(bv, true); break; } case LFUN_PROTECTEDSPACE: + //lyxerr << " called LFUN_PROTECTEDSPACE\n"; bv->lockedInsetStoreUndo(Undo::INSERT); - mathcursor->insert(new MathSpaceInset(1)); + mathcursor->insert(MathAtom(new MathSpaceInset(1))); updateLocal(bv, true); break; @@ -678,7 +563,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, { bv->lockedInsetStoreUndo(Undo::INSERT); lyxerr << "handling halign '" << arg << "'\n"; - int idx; + MathInset::idx_type idx; MathArrayInset * p = matrixpar(idx); if (!p) break; @@ -691,7 +576,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, { bv->lockedInsetStoreUndo(Undo::INSERT); lyxerr << "handling valign '" << arg << "'\n"; - int idx; + MathInset::idx_type idx; MathArrayInset * p = matrixpar(idx); if (!p) break; @@ -703,7 +588,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, case LFUN_MATH_ROW_INSERT: { bv->lockedInsetStoreUndo(Undo::INSERT); - int idx; + MathInset::idx_type idx; MathArrayInset * p = matrixpar(idx); lyxerr << " calling LFUN_MATH_ROW_INSERT on " << p << endl; if (!p) @@ -716,7 +601,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, case LFUN_MATH_ROW_DELETE: { bv->lockedInsetStoreUndo(Undo::INSERT); - int idx; + MathInset::idx_type idx; MathArrayInset * p = matrixpar(idx); lyxerr << " calling LFUN_MATH_ROW_DELETE on " << p << endl; if (!p) @@ -729,7 +614,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, case LFUN_MATH_COLUMN_INSERT: { bv->lockedInsetStoreUndo(Undo::INSERT); - int idx; + MathInset::idx_type idx; MathArrayInset * p = matrixpar(idx); if (!p) break; @@ -741,7 +626,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, case LFUN_MATH_COLUMN_DELETE: { bv->lockedInsetStoreUndo(Undo::INSERT); - int idx; + MathInset::idx_type idx; MathArrayInset * p = matrixpar(idx); if (!p) break; @@ -754,140 +639,37 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, result = UNDISPATCHED; break; - default: - if ((action == -1 || action == LFUN_SELFINSERT) && !arg.empty()) { - unsigned char c = arg[0]; - - lyxerr << "Action: " << action << endl; - - lyxerr << "char: '" << c << "' int: " << int(c) << endl; - //owner_->getIntl()->getTrans().TranslateAndInsert(c, lt); - //lyxerr << "trans: '" << c << "' int: " << int(c) << endl; - bv->lockedInsetStoreUndo(Undo::INSERT); - - if (c == 0) { // Dead key, do nothing - //lyxerr << "deadkey" << endl; - break; - } + case LFUN_BREAKPARAGRAPH: + case LFUN_BREAKPARAGRAPHKEEPLAYOUT: + //lyxerr << "LFUN ignored\n"; + break; - if (isalpha(c)) { - if (mathcursor->getLastCode() == LM_TC_TEX) { - mathcursor->MacroModeOpen(); - mathcursor->clearLastCode(); - varcode = LM_TC_MIN; - } else if (!varcode) { - MathTextCodes f = mathcursor->getLastCode() ? - mathcursor->getLastCode() : - mathcursor->nextCode(); - varcode = MathIsAlphaFont(f) ? - static_cast(f) : - LM_TC_VAR; - } - - // lyxerr << "Varcode << vardoce; - MathTextCodes char_code = varcode; - if (greek_kb_flag) { - char greek[26] = - {'A', 'B', 'X', 0 , 'E', 0 , 0 , 'H', 'I', 0 , - 'K', 0 , 'M', 'N', 'O', 0 , 0 , 'P', 0 , 'T', - 'Y', 0, 0, 0, 0 , 'Z' }; - - if ('A' <= c && c <= 'Z' && greek[c - 'A']) { - char_code = LM_TC_RM; - c = greek[c - 'A']; - } else - char_code = LM_TC_SYMB; - } - - mathcursor->insert(c, char_code); - - if (greek_kb_flag && char_code == LM_TC_RM ) - mathcursor->setLastCode(LM_TC_VAR); - - varcode = LM_TC_MIN; - - if (greek_kb_flag < 2) - greek_kb_flag = 0; - - } else if (strchr("!,:;{}", c) && (varcode == LM_TC_TEX||was_macro)) { - mathcursor->insert(c, LM_TC_TEX); - if (c == '{') { - mathcursor->insert('}', LM_TC_TEX); - mathcursor->Left(); - } - mathcursor->clearLastCode(); - // varcode = LM_TC_MIN; - } else if (c == '_' && varcode == LM_TC_TEX) { - mathcursor->insert(c, LM_TC_SPECIAL); - mathcursor->clearLastCode(); - // varcode = LM_TC_MIN; - } else if ('0' <= c && c <= '9' && (varcode == LM_TC_TEX||was_macro)) { - mathcursor->MacroModeOpen(); - mathcursor->clearLastCode(); - mathcursor->insert(c, LM_TC_MIN); - } else if (('0' <= c && c <= '9') || strchr(";:!|[]().,?", c)) { - MathTextCodes code = mathcursor->getLastCode(); - if (code != LM_TC_TEXTRM) - code = LM_TC_CONST; - mathcursor->insert(c, code); - } else if (strchr("+/-*<>=", c)) { - MathTextCodes code = mathcursor->getLastCode(); - if (code != LM_TC_TEXTRM) - code = LM_TC_BOP; - mathcursor->insert(c, code); - } else if (strchr(latex_special_chars, c) && c != '_') { - MathTextCodes code = mathcursor->getLastCode(); - if (code != LM_TC_TEXTRM) - code = LM_TC_SPECIAL; - mathcursor->insert(c, code); - } else if (c == '_' || c == '^') { - char s[2]; - s[0] = c; - s[1] = 0; - mathcursor->Interpret(s); - } else if (c == ' ') { - if (!varcode) { - MathTextCodes f = (mathcursor->getLastCode()) ? - mathcursor->getLastCode() : - mathcursor->nextCode(); - varcode = MathIsAlphaFont(f) ? f : LM_TC_VAR; - } - - if (varcode == LM_TC_TEXTRM) - mathcursor->insert(c, LM_TC_TEXTRM); - else if (was_macro) - mathcursor->MacroModeClose(); - else if (mathcursor->pop()) - mathcursor->plainRight(); - else { - // this would not work if the inset is in an table! - //bv->text->cursorRight(bv, true); - result = FINISHED; - } - } else if (c == '\'' || c == '@') { - mathcursor->insert(c, LM_TC_VAR); - } else if (c == '\\') { - if (was_macro) - mathcursor->MacroModeClose(); - bv->owner()->message(_("TeX mode")); - mathcursor->setLastCode(LM_TC_TEX); - } + case -1: + case LFUN_INSERT_MATH: + case LFUN_SELFINSERT: + if (!arg.empty()) { + bv->lockedInsetStoreUndo(Undo::INSERT); + mathcursor->interpret(arg); updateLocal(bv, true); - } else if (action == LFUN_MATH_PANEL) { - result = UNDISPATCHED; - } else { - lyxerr << "Closed by action " << action << endl; - result = FINISHED; } + break; + + case LFUN_MATH_PANEL: + result = UNDISPATCHED; + break; + + default: + result = UNDISPATCHED; } - mathcursor->normalize(); + lyx::Assert(mathcursor); + //mathcursor->normalize(); - if (was_macro != mathcursor->InMacroMode() - && action >= 0 && action != LFUN_BACKSPACE) + if (//was_macro != mathcursor->inMacroMode() && + action >= 0 && action != LFUN_BACKSPACE) updateLocal(bv, true); - if (mathcursor->Selection() || was_selection) + if (mathcursor->selection() || was_selection) toggleInsetSelection(bv); if (result == DISPATCHED || result == DISPATCHED_NOUPDATE || @@ -900,114 +682,82 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, } - -/* FIXME: math-greek-toggle seems to work OK, but math-greek doesn't turn - * on greek mode */ -bool math_insert_greek(BufferView * bv, char c) -{ - if (!bv->available()) - return false; - - if (!isalpha(c)) - return false; - - string tmp; - tmp = c; - if (!bv->theLockingInset() || bv->theLockingInset()->isTextInset()) { - int greek_kb_flag_save = greek_kb_flag; - InsetFormula * new_inset = new InsetFormula(); - bv->beforeChange(bv->text); - if (!bv->insertInset(new_inset)) { - delete new_inset; - return false; - } - //Update(1);//BUG - new_inset->edit(bv, 0, 0, 0); - new_inset->localDispatch(bv, LFUN_SELFINSERT, tmp); - if (greek_kb_flag_save < 2) { - bv->unlockInset(new_inset); // bv->theLockingInset()); - bv->text->cursorRight(bv, true); - } - } else - if (bv->theLockingInset()->lyxCode() == Inset::MATH_CODE || - bv->theLockingInset()->lyxCode() == Inset::MATHMACRO_CODE) - static_cast(bv->theLockingInset())->localDispatch(bv, LFUN_SELFINSERT, tmp); - else - lyxerr << "Math error: attempt to write on a wrong " - "class of inset." << endl; - return true; -} - - - Inset::Code InsetFormulaBase::lyxCode() const { return Inset::MATH_CODE; } -LyXFont const InsetFormulaBase::convertFont(LyXFont const & f) const +int InsetFormulaBase::upperY() const { - // We have already discussed what was here - LyXFont font(f); -#ifndef NO_LATEX - font.setLatex(LyXFont::OFF); -#endif - return font; + return yo_ - ascent(view_, font_); } -MathInset * InsetFormulaBase::par() const + +int InsetFormulaBase::lowerY() const { - return par_; + return yo_ + descent(view_, font_); } +///////////////////////////////////////////////////////////////////// + + void mathDispatchCreation(BufferView * bv, string const & arg, bool display) { if (bv->available()) { -// Feature "Read math inset from selection" disabled. -// // use selection if available.. -// string sel; -// if (action == LFUN_MATH_IMPORT_SELECTION) -// sel = ""; -// else -// sel = bv->getLyXText()->selectionAsString(bv->buffer()); - - InsetFormula * f; -// if (sel.empty()) { - f = new InsetFormula; - if (openNewInset(bv, f)) { - // don't do that also for LFUN_MATH_MODE unless you want end up with - // always changing to mathrm when opening an inlined inset - // -- I really hate "LyXfunc overloading"... - if (display) - f->localDispatch(bv, LFUN_MATH_DISPLAY, string()); - f->localDispatch(bv, LFUN_INSERT_MATH, arg); - } -// } else { -// f = new InsetFormula(sel); -// bv->getLyXText()->cutSelection(bv); -// openNewInset(bv, f); -// } + // use selection if available.. + //string sel; + //if (action == LFUN_MATH_IMPORT_SELECTION) + // sel = ""; + //else + + string sel = bv->getLyXText()->selectionAsString(bv->buffer(), false); + + InsetFormulaBase * f; + if (sel.empty()) { + f = new InsetFormula; + if (openNewInset(bv, f)) { + // don't do that also for LFUN_MATH_MODE unless you want end up with + // always changing to mathrm when opening an inlined inset + // -- I really hate "LyXfunc overloading"... + if (display) + f->localDispatch(bv, LFUN_MATH_DISPLAY, string()); + f->localDispatch(bv, LFUN_INSERT_MATH, arg); + } + } else { + // create a macro if we see "\\newcommand" somewhere, and an ordinary + // formula otherwise + if (sel.find("\\newcommand") == string::npos) + f = new InsetFormula(sel); + else + f = new InsetFormulaMacro(sel); + bv->getLyXText()->cutSelection(bv); + openNewInset(bv, f); + } } bv->owner()->getLyXFunc()->setMessage(N_("Math editor mode")); } + void mathDispatchMathDisplay(BufferView * bv, string const & arg) { mathDispatchCreation(bv, arg, true); } + void mathDispatchMathMode(BufferView * bv, string const & arg) { mathDispatchCreation(bv, arg, false); } + void mathDispatchMathImportSelection(BufferView * bv, string const & arg) { mathDispatchCreation(bv, arg, true); } + void mathDispatchMathMacro(BufferView * bv, string const & arg) { if (bv->available()) { @@ -1022,6 +772,7 @@ void mathDispatchMathMacro(BufferView * bv, string const & arg) } } + void mathDispatchMathDelim(BufferView * bv, string const & arg) { if (bv->available()) { @@ -1039,13 +790,29 @@ void mathDispatchInsertMatrix(BufferView * bv, string const & arg) } } + void mathDispatchInsertMath(BufferView * bv, string const & arg) { if (bv->available()) { - if (arg.size() && arg[0] == '\\') - openNewInset(bv, new InsetFormula(arg)); - else + if (arg.size() && arg[0] == '\\') { + InsetFormula * f = new InsetFormula(arg); + if (!bv->insertInset(f)) + delete f; + } else mathDispatchMathMode(bv, arg); } } + +void mathDispatchGreek(BufferView * bv, string const & arg) +{ + if (bv->available()) { + InsetFormula * f = new InsetFormula; + if (openNewInset(bv, f)) { + bv->theLockingInset()->localDispatch(bv, LFUN_GREEK, arg); + bv->unlockInset(f); + } + } +} + +