+void MathHullInset::doExtern
+ (FuncRequest const & func, idx_type & idx, pos_type & pos)
+{
+ string lang;
+ string extra;
+ istringstream iss(func.argument.c_str());
+ iss >> lang >> extra;
+ if (extra.empty())
+ extra = "noextra";
+
+#ifdef WITH_WARNINGS
+#warning temporarily disabled
+ //if (selection()) {
+ // MathArray ar;
+ // selGet(ar);
+ // lyxerr << "use selection: " << ar << endl;
+ // insert(pipeThroughExtern(lang, extra, ar));
+ // return;
+ //}
+#endif
+
+ MathArray eq;
+ eq.push_back(MathAtom(new MathCharInset('=')));
+
+ // go to first item in line
+ idx -= idx % ncols();
+ pos = 0;
+
+ if (getType() == "simple") {
+ size_type pos = cell(idx).find_last(eq);
+ MathArray ar;
+ if (mathcursor && mathcursor->selection()) {
+ asArray(mathcursor->grabAndEraseSelection(), ar);
+ } else if (pos == cell(idx).size()) {
+ ar = cell(idx);
+ lyxerr << "use whole cell: " << ar << endl;
+ } else {
+ ar = MathArray(cell(idx).begin() + pos + 1, cell(idx).end());
+ lyxerr << "use partial cell form pos: " << pos << endl;
+ }
+ cell(idx).append(eq);
+ cell(idx).append(pipeThroughExtern(lang, extra, ar));
+ pos = cell(idx).size();
+ return;
+ }
+
+ if (getType() == "equation") {
+ lyxerr << "use equation inset" << endl;
+ mutate("eqnarray");
+ MathArray & ar = cell(idx);
+ lyxerr << "use cell: " << ar << endl;
+ cell(idx + 1) = eq;
+ cell(idx + 2) = pipeThroughExtern(lang, extra, ar);
+ // move to end of line
+ idx += 2;
+ pos = cell(idx).size();
+ return;
+ }
+
+ {
+ lyxerr << "use eqnarray" << endl;
+ idx -= idx % ncols();
+ idx += 2;
+ pos = 0;
+ MathArray ar = cell(idx);
+ lyxerr << "use cell: " << ar << endl;
+#ifdef WITH_WARNINGS
+#warning temporarily disabled
+#endif
+ addRow(row(idx));
+ cell(idx + 2) = eq;
+ cell(idx + 3) = pipeThroughExtern(lang, extra, ar);
+ idx += 3;
+ pos = cell(idx).size();
+ }
+}
+
+
+dispatch_result MathHullInset::dispatch
+ (FuncRequest const & cmd, idx_type & idx, pos_type & pos)
+{
+ switch (cmd.action) {
+
+ case LFUN_BREAKLINE:
+ if (type_ == "simple" || type_ == "equation") {
+ mutate("eqnarray");
+ idx = 1;
+ pos = 0;
+ return DISPATCHED_POP;
+ }
+ return MathGridInset::dispatch(cmd, idx, pos);
+
+ case LFUN_MATH_NUMBER:
+ //lyxerr << "toggling all numbers" << endl;
+ if (display()) {
+ //recordUndo(bv, Undo::INSERT);
+ bool old = numberedType();
+ if (type_ == "multline")
+ numbered(nrows() - 1, !old);
+ else
+ for (row_type row = 0; row < nrows(); ++row)
+ numbered(row, !old);
+ //bv->owner()->message(old ? _("No number") : _("Number"));
+ }
+ return DISPATCHED;
+
+ case LFUN_MATH_NONUMBER:
+ if (display()) {
+ row_type r = (type_ == "multline") ? nrows() - 1 : row(idx);
+ //recordUndo(bv, Undo::INSERT);
+ bool old = numbered(r);
+ //bv->owner()->message(old ? _("No number") : _("Number"));
+ numbered(r, !old);
+ }
+ return DISPATCHED;
+
+ case LFUN_INSERT_LABEL: {
+ row_type r = (type_ == "multline") ? nrows() - 1 : row(idx);
+ string old_label = label(r);
+ string new_label = cmd.argument;
+
+ if (new_label.empty()) {
+ string const default_label =
+ (lyxrc.label_init_length >= 0) ? "eq:" : "";
+ pair<bool, string> const res = old_label.empty()
+ ? Alert::askForText(_("Enter new label to insert:"), default_label)
+ : Alert::askForText(_("Enter label:"), old_label);
+ if (!res.first)
+ return UNDISPATCHED;
+ new_label = trim(res.second);
+ }
+
+ //if (new_label == old_label)
+ // break; // Nothing to do
+
+ if (!new_label.empty())
+ numbered(r, true);
+ label(r, new_label);
+ return DISPATCHED;
+ }
+
+ case LFUN_MATH_EXTERN:
+ doExtern(cmd, idx, pos);
+ return DISPATCHED_POP;
+
+ case LFUN_MATH_MUTATE: {
+ row_type r = row(idx);
+ col_type c = col(idx);
+ mutate(cmd.argument);
+ idx = r * ncols() + c;
+ if (idx >= nargs())
+ idx = nargs() - 1;
+ if (pos > cell(idx).size())
+ pos = cell(idx).size();
+ return DISPATCHED_POP;
+ }
+
+ case LFUN_MATH_DISPLAY: {
+ mutate(type_ == "simple" ? "equation" : "simple");
+ idx = 0;
+ pos = cell(idx).size();
+ return DISPATCHED_POP;
+ }
+
+ default:
+ return MathGridInset::dispatch(cmd, idx, pos);
+ }
+}
+
+
+string MathHullInset::fileInsetLabel() const
+{
+ return "Formula";
+}