X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fmath_hullinset.C;h=4f5a81d29b9d640feb48e1006cc34819102eba8a;hb=b8b975cd52a631a2e832beb94f77e9b98182015d;hp=0114359321150206046b0d88594b911f201eb801;hpb=66e5a9eea1527ebf158b7069952a25440559fddb;p=lyx.git

diff --git a/src/mathed/math_hullinset.C b/src/mathed/math_hullinset.C
index 0114359321..4f5a81d29b 100644
--- a/src/mathed/math_hullinset.C
+++ b/src/mathed/math_hullinset.C
@@ -8,18 +8,27 @@
 #include "math_mathmlstream.h"
 #include "math_streamstr.h"
 #include "math_support.h"
+#include "math_extern.h"
+#include "math_charinset.h"
 #include "debug.h"
-#include "frontends/Painter.h"
 #include "textpainter.h"
+#include "funcrequest.h"
 #include "Lsstream.h"
 #include "LaTeXFeatures.h"
 #include "support/LAssert.h"
+#include "frontends/Painter.h"
+
+#include "frontends/Alert.h"
+#include "lyxrc.h"
+#include "gettext.h"
+#include "BufferView.h"
 
 #include <vector>
 
 using std::vector;
 using std::max;
 using std::endl;
+using std::pair;
 
 namespace {
 
@@ -248,7 +257,7 @@ string MathHullInset::label(row_type row) const
 
 void MathHullInset::label(row_type row, string const & label)
 {
-	lyxerr << "setting label '" << label << "' for row " << row << endl;
+	//lyxerr << "setting label '" << label << "' for row " << row << endl;
 	label_[row] = label;
 }
 
@@ -347,18 +356,18 @@ void MathHullInset::header_write(WriteStream & os) const
 	else if (type_ == "eqnarray" || type_ == "align")
 			os << "\\begin{" << type_ << star(n) << "}\n";
 
-	else if (type_ == "alignat" || type_ == "xalignat") 
+	else if (type_ == "alignat" || type_ == "xalignat")
 		os << "\\begin{" << type_ << star(n) << "}"
 		  << "{" << static_cast<unsigned int>((ncols() + 1)/2) << "}\n";
- 
-	else if (type_ == "xxalignat") 
+
+	else if (type_ == "xxalignat")
 		os << "\\begin{" << type_ << "}"
 		  << "{" << static_cast<unsigned int>((ncols() + 1)/2) << "}\n";
- 
-	else if (type_ == "multline" || type_ == "gather") 
+
+	else if (type_ == "multline" || type_ == "gather")
 		os << "\\begin{" << type_ << "}\n";
 
-	else 
+	else
 		os << "\\begin{unknown" << star(n) << "}";
 }
 
@@ -391,6 +400,14 @@ void MathHullInset::footer_write(WriteStream & os) const
 }
 
 
+bool MathHullInset::colChangeOK() const
+{
+	return
+		type_ == "align" || type_ == "alignat" ||
+		type_ == "xalignat" || type_ == "xxalignat";
+}
+
+
 void MathHullInset::addRow(row_type row)
 {
 	nonum_.insert(nonum_.begin() + row + 1, !numberedType());
@@ -401,32 +418,29 @@ void MathHullInset::addRow(row_type row)
 
 void MathHullInset::delRow(row_type row)
 {
+	if (nrows() <= 1)
+		return;
 	MathGridInset::delRow(row);
 	nonum_.erase(nonum_.begin() + row);
 	label_.erase(label_.begin() + row);
 }
 
 
-void MathHullInset::addFancyCol(col_type col)
+void MathHullInset::addCol(col_type col)
 {
-	if (type_ == "equation")
-		mutate("eqnarray");
-	
-	else if (type_ == "eqnarray") {
-		mutate("align");
-		addFancyCol(col);
-	}
-
-	else if (type_ == "align" || type_ == "alignat"
-	      || type_ == "xalignat" || type_ == "xxalignat") 
+	if (colChangeOK()) 
 		MathGridInset::addCol(col);
+	else
+		lyxerr << "Can't change number of columns in '" << type_ << "'\n";
 }
 
 
-void MathHullInset::delFancyCol(col_type col)
+void MathHullInset::delCol(col_type col)
 {
-	if (type_ == "alignat" || type_ == "xalignat" || type_ == "xxalignat") 
+	if (colChangeOK()) 
 		MathGridInset::delCol(col);
+	else
+		lyxerr << "Can't change number of columns in '" << type_ << "'\n";
 }
 
 
@@ -470,7 +484,7 @@ void MathHullInset::mutate(string const & newtype)
 	//lyxerr << "mutating from '" << type_ << "' to '" << newtype << "'\n";
 
 	// we try to move along the chain
-	// none <-> simple <-> equation <-> eqnarray 
+	// none <-> simple <-> equation <-> eqnarray
 
 	if (newtype == "dump") {
 		dump();
@@ -515,6 +529,9 @@ void MathHullInset::mutate(string const & newtype)
 			}
 			setType("eqnarray");
 			mutate(newtype);
+		} else if (newtype == "multline" || newtype == "gather") {
+			setType(newtype);
+			numbered(0, false);
 		} else {
 			MathGridInset::addCol(1);
 			// split it "nicely"
@@ -570,12 +587,16 @@ void MathHullInset::mutate(string const & newtype)
 	}
 
 	else if (type_ == "multline") {
-		if (newtype == "gather") {
-			setType("gather");
+		if (newtype == "gather" || newtype == "align" ||	
+		           newtype == "xalign" || newtype == "xxalign")
+			setType(newtype);
+		else if (newtype == "eqnarray") {
+			MathGridInset::addCol(1);
+			MathGridInset::addCol(1);
+			setType("eqnarray");
 		} else {
 			lyxerr << "mutation from '" << type_
-				<< "' to '" << newtype << "' not implemented"
-						 << endl;
+				<< "' to '" << newtype << "' not implemented" << endl;
 		}
 	}
 
@@ -595,24 +616,23 @@ void MathHullInset::mutate(string const & newtype)
 }
 
 
-void MathHullInset::write(WriteStream & os) const
+string MathHullInset::eolString(row_type row, bool fragile) const
 {
-	header_write(os);
-
-	bool n = numberedType();
-
-	for (row_type row = 0; row < nrows(); ++row) {
-		for (col_type col = 0; col < ncols(); ++col)
-			os << cell(index(row, col)) << eocString(col);
-		if (n) {
-			if (!label_[row].empty())
-				os << "\\label{" << label_[row] << "}";
-			if (nonum_[row])
-				os << "\\nonumber ";
-		}
-		os << eolString(row);
+	string res;
+	if (numberedType()) {
+		if (!label_[row].empty())
+			res += "\\label{" + label_[row] + "}";
+		if (nonum_[row])
+			res += "\\nonumber ";
 	}
+	return res + MathGridInset::eolString(row, fragile);
+}
+
 
+void MathHullInset::write(WriteStream & os) const
+{
+	header_write(os);
+	MathGridInset::write(os);
 	footer_write(os);
 }
 
@@ -642,3 +662,178 @@ void MathHullInset::check() const
 	lyx::Assert(nonum_.size() == nrows());
 	lyx::Assert(label_.size() == nrows());
 }
+
+
+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 << "\n";
+	//	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 (pos == cell(idx).size()) {
+			ar = cell(idx);
+			lyxerr << "use whole cell: " << ar << "\n";
+		} else {
+			ar = MathArray(cell(idx).begin() + pos + 1, cell(idx).end());
+			lyxerr << "use partial cell form pos: " << pos << "\n";
+		}
+		cell(idx).append(eq);
+		cell(idx).append(pipeThroughExtern(lang, extra, ar));
+		pos = cell(idx).size();
+		return;
+	}
+
+	if (getType() == "equation") {
+		lyxerr << "use equation inset\n";
+		mutate("eqnarray");
+		MathArray & ar = cell(idx);
+		lyxerr << "use cell: " << ar << "\n";
+		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\n";
+		idx -= idx % ncols();
+		idx += 2;
+		pos = 0;
+		MathArray ar = cell(idx);
+		lyxerr << "use cell: " << ar << "\n";
+#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();
+	}
+}
+
+
+MathInset::result_type 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\n";
+			if (display()) {
+				//bv->lockedInsetStoreUndo(Undo::INSERT);
+				bool old = numberedType();
+				for (row_type row = 0; row < nrows(); ++row)
+					numbered(row, !old);
+				//bv->owner()->message(old ? _("No number") : _("Number"));
+				//updateLocal(bv, true);
+			}
+			return DISPATCHED;
+
+		case LFUN_MATH_NONUMBER:
+			if (display()) {
+				//bv->lockedInsetStoreUndo(Undo::INSERT);
+				bool old = numbered(row(idx));
+				//bv->owner()->message(old ? _("No number") : _("Number"));
+				numbered(row(idx), !old);
+				//updateLocal(bv, true);
+			}
+			return DISPATCHED;
+
+		case LFUN_INSERT_LABEL: {
+			row_type r = 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)
+					break;
+				new_label = trim(res.second);
+			}
+
+			//if (new_label == old_label)
+			//	break;  // Nothing to do
+
+			if (!new_label.empty())
+				numbered(r, true);
+
+#warning FIXME: please check you really mean repaint() ... is it needed,
+#warning and if so, should it be update() instead ?
+			if (!new_label.empty()
+					&& cmd.view()->ChangeRefsIfUnique(old_label, new_label))
+				cmd.view()->repaint();
+
+			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);
+
+	}
+	return UNDISPATCHED;
+}