X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fformulabase.C;h=3d36585989575072d4ee786e6855e1b72dfc94e3;hb=cf629f43316e5f20f97128a10ea14e0b4215b056;hp=2a06ceb9a980a846aa1fdc99b6c2a6db82871659;hpb=d18d31df77da2e29fde24e1933365c39f27d78c4;p=lyx.git diff --git a/src/mathed/formulabase.C b/src/mathed/formulabase.C index 2a06ceb9a9..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,7 +26,6 @@ #include "formulamacro.h" #include "commandtags.h" #include "math_cursor.h" -#include "math_parser.h" #include "BufferView.h" #include "lyxtext.h" #include "lyxfunc.h" @@ -61,13 +60,6 @@ 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()) @@ -99,10 +91,10 @@ bool openNewInset(BufferView * bv, UpdatableInset * new_inset) // returns the nearest enclosing grid -MathArrayInset * matrixpar(int & idx) +MathArrayInset * matrixpar(MathInset::idx_type & idx) { idx = 0; - return (mathcursor ? mathcursor->enclosingArray(idx) : 0); + return mathcursor ? mathcursor->enclosingArray(idx) : 0; } @@ -111,58 +103,29 @@ MathArrayInset * matrixpar(int & idx) InsetFormulaBase::InsetFormulaBase() + : view_(0), font_(), xo_(0), yo_(0) { -#ifdef WITH_WARNINGS -#warning This is needed as long the math parser is not re-entrant -#endif + // This is needed as long the math parser is not re-entrant MathMacroTable::builtinMacros(); //lyxerr << "sizeof MathInset: " << sizeof(MathInset) << "\n"; } -void InsetFormulaBase::read(Buffer const *, LyXLex & lex) -{ - read(lex); -} - - -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); -} - - -int InsetFormulaBase::linuxdoc(Buffer const *, ostream & os) const -{ - return linuxdoc(os); -} +// Check if uses AMS macros +void InsetFormulaBase::validate(LaTeXFeatures &) const +{} -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"); @@ -171,19 +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(); + 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); - if (x == 0) - mathcursor->first(); - else - mathcursor->last(); sel_x = 0; sel_y = 0; sel_flag = false; @@ -214,8 +172,9 @@ void InsetFormulaBase::insetUnlock(BufferView * bv) void InsetFormulaBase::getCursorPos(BufferView *, int & x, int & y) const { mathcursor->getPos(x, y); - x -= par()->xo(); - y -= par()->yo(); + x += xo_; + y += yo_ - 3; + //lyxerr << "getCursorPos: " << x << " " << y << "\n"; } @@ -227,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); + 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(); @@ -249,12 +211,13 @@ void InsetFormulaBase::showInsetCursor(BufferView * bv, bool) 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); + 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); } @@ -283,7 +246,7 @@ vector const InsetFormulaBase::getLabelList() const void InsetFormulaBase::updateLocal(BufferView * bv, bool dirty) { - metrics(); + metrics(bv); bv->updateInset(this, dirty); } @@ -293,9 +256,8 @@ void InsetFormulaBase::insetButtonRelease(BufferView * bv, { 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; @@ -326,14 +288,12 @@ 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->setPos(sel_x, sel_y); mathcursor->selStart(); showInsetCursor(bv); mathcursor->getPos(sel_x, sel_y); } else if (sel_flag) { hideInsetCursor(bv); - x += par()->xo(); - y += par()->yo(); mathcursor->setPos(x, y); showInsetCursor(bv); mathcursor->getPos(x, y); @@ -351,19 +311,21 @@ void InsetFormulaBase::insetKeyPress(XKeyEvent *) } -int greek_kb_flag = 0; - 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; + if (mathcursor->asHyperActiveInset()) { + lyxerr << " uurr.... getting dificult now\n"; + return mathcursor->asHyperActiveInset()->localDispatch(bv, action, arg); + } + RESULT result = DISPATCHED; bool sel = false; bool was_macro = mathcursor->inMacroMode(); @@ -412,13 +374,19 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, 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; @@ -444,12 +412,14 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, updateLocal(bv, true); break; + case LFUN_DELETE_WORD_BACKWARD: case LFUN_BACKSPACE: bv->lockedInsetStoreUndo(Undo::DELETE); mathcursor->backspace(); bv->updateInset(this, true); break; + case LFUN_DELETE_WORD_FORWARD: case LFUN_DELETE: bv->lockedInsetStoreUndo(Undo::DELETE); mathcursor->erase(); @@ -462,14 +432,11 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, // break; 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; } @@ -492,8 +459,6 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, mathcursor->selCopy(); break; - case LFUN_HOMESEL: - case LFUN_ENDSEL: case LFUN_WORDRIGHTSEL: case LFUN_WORDLEFTSEL: break; @@ -512,15 +477,21 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, case LFUN_VECTOR: handleAccent(bv, "vec"); break; // Math fonts - case LFUN_GREEK: handleFont(bv, LM_TC_GREEK1); break; 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; + case LFUN_MATH_MODE: handleFont(bv, LM_TC_TEXTRM); //bv->owner()->message(_("math text mode toggled")); @@ -533,12 +504,13 @@ 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: @@ -552,12 +524,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, case LFUN_MATH_SPACE: { bv->lockedInsetStoreUndo(Undo::EDIT); - //MathSpaceInset * p = mathcursor->prevSpaceInset(); - //if (p) - // p->incSpace(); - //else - // mathcursor->insert(new MathSpaceInset(1)); - mathcursor->insert(new MathSpaceInset(1)); + mathcursor->insert(MathAtom(new MathSpaceInset(1))); updateLocal(bv, true); break; } @@ -570,14 +537,12 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, string rs; istringstream is(arg.c_str()); is >> ls >> rs; - latexkeys const * l = in_word_set(ls); - latexkeys const * r = in_word_set(rs); - if (!is || !l || !r) { + if (!is) { lyxerr << "can't parse delimeters from '" << arg << "'\n"; break; } bv->lockedInsetStoreUndo(Undo::EDIT); - mathcursor->handleDelim(l, r); + mathcursor->handleDelim(ls, rs); updateLocal(bv, true); break; } @@ -585,7 +550,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, 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; @@ -598,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; @@ -611,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; @@ -623,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) @@ -636,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) @@ -649,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; @@ -661,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; @@ -674,6 +639,11 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, result = UNDISPATCHED; break; + case LFUN_BREAKPARAGRAPH: + case LFUN_BREAKPARAGRAPHKEEPLAYOUT: + //lyxerr << "LFUN ignored\n"; + break; + case -1: case LFUN_INSERT_MATH: case LFUN_SELFINSERT: @@ -689,14 +659,14 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action, break; default: - lyxerr << "Closed by action " << action << endl; - result = FINISHED_RIGHT; + 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) @@ -718,6 +688,21 @@ Inset::Code InsetFormulaBase::lyxCode() const } +int InsetFormulaBase::upperY() const +{ + return yo_ - ascent(view_, font_); +} + + +int InsetFormulaBase::lowerY() const +{ + return yo_ + descent(view_, font_); +} + + +///////////////////////////////////////////////////////////////////// + + void mathDispatchCreation(BufferView * bv, string const & arg, bool display) { if (bv->available()) { @@ -727,19 +712,19 @@ void mathDispatchCreation(BufferView * bv, string const & arg, bool display) // sel = ""; //else - string sel = bv->getLyXText()->selectionAsString(bv->buffer()); + 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); - } + 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 @@ -754,6 +739,7 @@ void mathDispatchCreation(BufferView * bv, string const & arg, bool display) bv->owner()->getLyXFunc()->setMessage(N_("Math editor mode")); } + void mathDispatchMathDisplay(BufferView * bv, string const & arg) { mathDispatchCreation(bv, arg, true); @@ -808,10 +794,25 @@ 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); + } + } +} + +