X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Finsets%2FInsetBranch.cpp;h=9af5c9e8b77d00ea9377b97a1d277f42b4ff19af;hb=f881835da210fa98d822010c3c9afae4d65d5572;hp=a09f130a26a50566938820f30420f9e3378553d2;hpb=e33efb3c31b18de791aa35581f9ad8385bd3bb62;p=lyx.git

diff --git a/src/insets/InsetBranch.cpp b/src/insets/InsetBranch.cpp
index a09f130a26..db047c2f3d 100644
--- a/src/insets/InsetBranch.cpp
+++ b/src/insets/InsetBranch.cpp
@@ -14,157 +14,174 @@
 
 #include "Buffer.h"
 #include "BufferParams.h"
+#include "BufferView.h"
 #include "BranchList.h"
+#include "ColorSet.h"
 #include "Counters.h"
 #include "Cursor.h"
 #include "DispatchResult.h"
 #include "FuncRequest.h"
 #include "FuncStatus.h"
-#include "gettext.h"
 #include "Lexer.h"
+#include "LyX.h"
 #include "OutputParams.h"
+#include "output_xhtml.h"
+#include "TextClass.h"
+#include "TocBackend.h"
 
-#include <sstream>
-
-
-namespace lyx {
-
-using std::string;
-using std::istringstream;
-using std::ostream;
-using std::ostringstream;
+#include "support/debug.h"
+#include "support/gettext.h"
+#include "support/lstrings.h"
 
+#include "frontends/alert.h"
+#include "frontends/Application.h"
 
-InsetBranch::InsetBranch(BufferParams const & bp,
-			 InsetBranchParams const & params)
-	: InsetCollapsable(bp), params_(params)
-{
-	setButtonLabel();
-}
+#include <sstream>
 
+using namespace std;
 
-InsetBranch::InsetBranch(InsetBranch const & in)
-	: InsetCollapsable(in), params_(in.params_)
-{
-	setButtonLabel();
-}
 
+namespace lyx {
 
-InsetBranch::~InsetBranch()
-{
-	InsetBranchMailer(*this).hideDialog();
-}
+InsetBranch::InsetBranch(Buffer * buf, InsetBranchParams const & params)
+	: InsetCollapsable(buf, InsetText::DefaultLayout), params_(params)
+{}
 
 
-Inset * InsetBranch::clone() const
+void InsetBranch::write(ostream & os) const
 {
-	return new InsetBranch(*this);
+	os << "Branch ";
+	params_.write(os);
+	os << '\n';
+	InsetCollapsable::write(os);
 }
 
 
-docstring const InsetBranch::editMessage() const
+void InsetBranch::read(Lexer & lex)
 {
-	return _("Opened Branch Inset");
+	params_.read(lex);
+	InsetCollapsable::read(lex);
 }
 
 
-void InsetBranch::write(Buffer const & buf, ostream & os) const
+docstring InsetBranch::toolTip(BufferView const & bv, int, int) const
 {
-	params_.write(os);
-	InsetCollapsable::write(buf, os);
+	docstring const masterstatus = isBranchSelected() ?
+		_("active") : _("non-active");
+	docstring const childstatus = isBranchSelected(true) ?
+		_("active") : _("non-active");
+	docstring const status = (masterstatus == childstatus) ?
+		masterstatus :
+		support::bformat(_("master: %1$s, child: %2$s"),
+						 masterstatus, childstatus);
+	docstring const heading = 
+		support::bformat(_("Branch (%1$s): %2$s"), status, params_.branch);
+	if (isOpen(bv))
+		return heading;
+	return toolTipText(heading + from_ascii("\n"));
 }
 
 
-void InsetBranch::read(Buffer const & buf, Lexer & lex)
-{
-	params_.read(lex);
-	InsetCollapsable::read(buf, lex);
-}
-
-
-void InsetBranch::setButtonLabel()
+docstring const InsetBranch::buttonLabel(BufferView const & bv) const
 {
 	docstring s = _("Branch: ") + params_.branch;
+	Buffer const & realbuffer = *buffer().masterBuffer();
+	BranchList const & branchlist = realbuffer.params().branchlist();
+	bool const inmaster = branchlist.find(params_.branch);
+	bool const inchild = buffer().params().branchlist().find(params_.branch);
+	if (!inmaster && inchild)
+		s = _("Branch (child only): ") + params_.branch;
+	else if (inmaster && !inchild)
+		s = _("Branch (master only): ") + params_.branch;
+	else if (!inmaster)
+		s = _("Branch (undefined): ") + params_.branch;
 	if (!params_.branch.empty()) {
 		// FIXME UNICODE
 		ColorCode c = lcolor.getFromLyXName(to_utf8(params_.branch));
-		if (c == Color_none) {
+		if (c == Color_none)
 			s = _("Undef: ") + s;
-		}
 	}
-	if (decoration() == Classic)
-		setLabel(isOpen() ? s : getNewLabel(s) );
+	bool const master_selected = isBranchSelected();
+	bool const child_selected = isBranchSelected(true);
+	docstring symb = docstring(1, char_type(master_selected ? 0x2714 : 0x2716));
+	if (inchild && master_selected != child_selected)
+		symb += char_type(child_selected ? 0x2714 : 0x2716);
+	s = symb + s;
+	if (decoration() == InsetLayout::CLASSIC)
+		return isOpen(bv) ? s : getNewLabel(s);
 	else
-		setLabel(params_.branch + ": " + getNewLabel(s));
-}
-
-
-ColorCode InsetBranch::backgroundColor() const
-{
-	if (!params_.branch.empty()) {
-		// FIXME UNICODE
-		ColorCode c = lcolor.getFromLyXName(to_utf8(params_.branch));
-		if (c == Color_none) {
-			c = Color_error;
-		}
-		return c;
-	} else
-		return Inset::backgroundColor();
+		return params_.branch + ": " + getNewLabel(s);
 }
 
 
-bool InsetBranch::showInsetDialog(BufferView * bv) const
+ColorCode InsetBranch::backgroundColor(PainterInfo const & pi) const
 {
-	InsetBranchMailer(const_cast<InsetBranch &>(*this)).showDialog(bv);
-	return true;
+	if (params_.branch.empty())
+		return Inset::backgroundColor(pi);
+	// FIXME UNICODE
+	ColorCode c = lcolor.getFromLyXName(to_utf8(params_.branch));
+	if (c == Color_none)
+		c = Color_error;
+	return c;
 }
 
 
 void InsetBranch::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
-	switch (cmd.action) {
+	switch (cmd.action()) {
 	case LFUN_INSET_MODIFY: {
 		InsetBranchParams params;
-		InsetBranchMailer::string2params(to_utf8(cmd.argument()), params);
+		InsetBranch::string2params(to_utf8(cmd.argument()), params);
+
+		cur.recordUndoInset(ATOMIC_UNDO, this);
 		params_.branch = params.branch;
-		setLayout(cur.buffer().params());
+		// what we really want here is a TOC update, but that means
+		// a full buffer update
+		cur.forceBufferUpdate();
 		break;
 	}
-
-	case LFUN_MOUSE_PRESS:
-		if (cmd.button() != mouse_button::button3)
-			InsetCollapsable::doDispatch(cur, cmd);
-		else
-			cur.undispatched();
-		break;
-
-	case LFUN_INSET_DIALOG_UPDATE:
-		InsetBranchMailer(*this).updateDialog(&cur.bv());
+	case LFUN_BRANCH_ACTIVATE:
+	case LFUN_BRANCH_DEACTIVATE:
+	case LFUN_BRANCH_MASTER_ACTIVATE:
+	case LFUN_BRANCH_MASTER_DEACTIVATE: {
+		bool const master = (cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE
+				     || cmd.action() == LFUN_BRANCH_MASTER_DEACTIVATE);
+		Buffer * buf = master ? const_cast<Buffer *>(buffer().masterBuffer())
+				      : &buffer();
+
+		Branch * our_branch = buf->params().branchlist().find(params_.branch);
+		if (!our_branch)
+			break;
+
+		bool const activate = (cmd.action() == LFUN_BRANCH_ACTIVATE
+				       || cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE);
+		if (our_branch->isSelected() != activate) {
+			// FIXME If the branch is in the master document, we cannot
+			// call recordUndo..., because the master may be hidden, and
+			// the code presently assumes that hidden documents can never
+			// be dirty. See GuiView::closeBufferAll(), for example.
+			// An option would be to check if the master is hidden.
+			// If it is, unhide.
+			if (!master)
+				buffer().undo().recordUndoFullDocument(cur);
+			else
+				// at least issue a warning for now (ugly, but better than dataloss).
+				frontend::Alert::warning(_("Branch state changes in master document"),
+				    lyx::support::bformat(_("The state of the branch '%1$s' "
+					"was changed in the master file. "
+					"Please make sure to save the master."), params_.branch), true);
+			our_branch->setSelected(activate);
+			// cur.forceBufferUpdate() is not enough
+			buf->updateBuffer();
+		}
 		break;
-
-	case LFUN_MOUSE_RELEASE:
-		if (cmd.button() == mouse_button::button3 && hitButton(cmd))
-			InsetBranchMailer(*this).showDialog(&cur.bv());
-		else
-			InsetCollapsable::doDispatch(cur, cmd);
+	}
+	case LFUN_BRANCH_ADD:
+		lyx::dispatch(FuncRequest(LFUN_BRANCH_ADD, params_.branch));
 		break;
-
-
 	case LFUN_INSET_TOGGLE:
-		if (cmd.argument() == "assign") {
-			// The branch inset uses "assign".
-			if (isBranchSelected(cur.buffer())) {
-				if (status() != Open)
-					setStatus(cur, Open);
-				else
-					cur.undispatched();
-			} else {
-				if (status() != Collapsed)
-					setStatus(cur, Collapsed);
-				else
-					cur.undispatched();
-			}
-		}
+		if (cmd.argument() == "assign")
+			setStatus(cur, isBranchSelected() ? Open : Collapsed);
 		else
 			InsetCollapsable::doDispatch(cur, cmd);
 		break;
@@ -179,24 +196,41 @@ void InsetBranch::doDispatch(Cursor & cur, FuncRequest & cmd)
 bool InsetBranch::getStatus(Cursor & cur, FuncRequest const & cmd,
 		FuncStatus & flag) const
 {
-	switch (cmd.action) {
+	bool const known_branch =
+		buffer().params().branchlist().find(params_.branch);
+
+	switch (cmd.action()) {
 	case LFUN_INSET_MODIFY:
-	case LFUN_INSET_DIALOG_UPDATE:
-		flag.enabled(true);
+		flag.setEnabled(true);
+		break;
+
+	case LFUN_BRANCH_ACTIVATE:
+		flag.setEnabled(known_branch && !isBranchSelected(true));
+		break;
+
+	case LFUN_BRANCH_ADD:
+		flag.setEnabled(!known_branch);
+		break;
+
+	case LFUN_BRANCH_DEACTIVATE:
+		flag.setEnabled(isBranchSelected(true));
+		break;
+
+	case LFUN_BRANCH_MASTER_ACTIVATE:
+		flag.setEnabled(buffer().parent()
+				&& buffer().masterBuffer()->params().branchlist().find(params_.branch)
+				&& !isBranchSelected());
+		break;
+
+	case LFUN_BRANCH_MASTER_DEACTIVATE:
+		flag.setEnabled(buffer().parent() && isBranchSelected());
 		break;
 
 	case LFUN_INSET_TOGGLE:
-		if (cmd.argument() == "open" || cmd.argument() == "close" ||
-		    cmd.argument() == "toggle")
-			flag.enabled(true);
-		else if (cmd.argument() == "assign"
-			   || cmd.argument().empty()) {
-			if (isBranchSelected(cur.buffer()))
-				flag.enabled(status() != Open);
-			else
-				flag.enabled(status() != Collapsed);
-		} else
-			flag.enabled(true);
+		if (cmd.argument() == "assign")
+			flag.setEnabled(true);
+		else
+			return InsetCollapsable::getStatus(cur, cmd, flag);	
 		break;
 
 	default:
@@ -206,135 +240,139 @@ bool InsetBranch::getStatus(Cursor & cur, FuncRequest const & cmd,
 }
 
 
-bool InsetBranch::isBranchSelected(Buffer const & buffer) const
+bool InsetBranch::isBranchSelected(bool const child) const
 {
-	Buffer const & realbuffer = *buffer.masterBuffer();
+	Buffer const & realbuffer = child ? buffer() : *buffer().masterBuffer();
 	BranchList const & branchlist = realbuffer.params().branchlist();
-	BranchList::const_iterator const end = branchlist.end();
-	BranchList::const_iterator it =
-		std::find_if(branchlist.begin(), end,
-			     BranchNamesEqual(params_.branch));
-	if (it == end)
-		return false;
-	return it->getSelected();
-}
+	Branch const * ourBranch = branchlist.find(params_.branch);
 
-
-void InsetBranch::updateLabels(Buffer const & buf, ParIterator const & it)
-{
-	if (isBranchSelected(buf))
-		InsetCollapsable::updateLabels(buf, it);
-	else {
-		TextClass const & tclass = buf.params().getTextClass();
-		Counters savecnt = tclass.counters();
-		InsetCollapsable::updateLabels(buf, it);
-		tclass.counters() = savecnt;
+	if (!ourBranch) {
+		// this branch is defined in child only
+		ourBranch = buffer().params().branchlist().find(params_.branch);
+		if (!ourBranch)
+			return false;
 	}
+	return ourBranch->isSelected();
 }
 
 
-int InsetBranch::latex(Buffer const & buf, odocstream & os,
-		       OutputParams const & runparams) const
+void InsetBranch::latex(otexstream & os, OutputParams const & runparams) const
 {
-	return isBranchSelected(buf) ?
-		InsetText::latex(buf, os, runparams) : 0;
+	if (isBranchSelected())
+		InsetText::latex(os, runparams);
 }
 
 
-int InsetBranch::plaintext(Buffer const & buf, odocstream & os,
+int InsetBranch::plaintext(odocstream & os,
 			   OutputParams const & runparams) const
 {
-	if (!isBranchSelected(buf))
+	if (!isBranchSelected())
 		return 0;
 
-	os << '[' << buf.B_("branch") << ' ' << params_.branch << ":\n";
-	InsetText::plaintext(buf, os, runparams);
-	os << "\n]";
-
-	return PLAINTEXT_NEWLINE + 1; // one char on a separate line
+	int len = InsetText::plaintext(os, runparams);
+	return len;
 }
 
 
-int InsetBranch::docbook(Buffer const & buf, odocstream & os,
+int InsetBranch::docbook(odocstream & os,
 			 OutputParams const & runparams) const
 {
-	return isBranchSelected(buf) ?
-		InsetText::docbook(buf, os, runparams) : 0;
+	return isBranchSelected() ?  InsetText::docbook(os, runparams) : 0;
 }
 
 
-void InsetBranch::textString(Buffer const & buf, odocstream & os) const
+docstring InsetBranch::xhtml(XHTMLStream & xs, OutputParams const & rp) const
 {
-	if (isBranchSelected(buf))
-		os << paragraphs().begin()->asString(buf, true);
+	if (isBranchSelected()) {
+		OutputParams newrp = rp;
+		newrp.par_begin = 0;
+		newrp.par_end = text().paragraphs().size();
+		xhtmlParagraphs(text(), buffer(), xs, newrp);
+	}
+	return docstring();
 }
 
 
-void InsetBranch::validate(LaTeXFeatures & features) const
+void InsetBranch::toString(odocstream & os) const
 {
-	InsetText::validate(features);
+	if (isBranchSelected())
+		InsetCollapsable::toString(os);
 }
 
 
+void InsetBranch::forToc(docstring & os, size_t maxlen) const
+{
+	if (isBranchSelected())
+		InsetCollapsable::forToc(os, maxlen);
+}
 
-string const InsetBranchMailer::name_("branch");
 
-InsetBranchMailer::InsetBranchMailer(InsetBranch & inset)
-	: inset_(inset)
-{}
+void InsetBranch::validate(LaTeXFeatures & features) const
+{
+	if (isBranchSelected())
+		InsetCollapsable::validate(features);
+}
+
+
+string InsetBranch::contextMenuName() const
+{
+	return "context-branch";
+}
 
 
-string const InsetBranchMailer::inset2string(Buffer const &) const
+bool InsetBranch::isMacroScope() const 
 {
-	return params2string(inset_.params());
+	// Its own scope if not selected by buffer
+	return !isBranchSelected();
 }
 
 
-string const InsetBranchMailer::params2string(InsetBranchParams const & params)
+string InsetBranch::params2string(InsetBranchParams const & params)
 {
 	ostringstream data;
-	data << name_ << ' ';
 	params.write(data);
 	return data.str();
 }
 
 
-void InsetBranchMailer::string2params(string const & in,
-				      InsetBranchParams & params)
+void InsetBranch::string2params(string const & in, InsetBranchParams & params)
 {
 	params = InsetBranchParams();
 	if (in.empty())
 		return;
 
 	istringstream data(in);
-	Lexer lex(0,0);
+	Lexer lex;
 	lex.setStream(data);
+	lex.setContext("InsetBranch::string2params");
+	params.read(lex);
+}
 
-	string name;
-	lex >> name;
-	if (name != name_)
-		return print_mailer_error("InsetBranchMailer", in, 1, name_);
-
-	// This is part of the inset proper that is usually swallowed
-	// by Text::readInset
-	string id;
-	lex >> id;
-	if (!lex || id != "Branch")
-		return print_mailer_error("InsetBranchMailer", in, 2, "Branch");
 
-	params.read(lex);
+void InsetBranch::addToToc(DocIterator const & cpit) const
+{
+	DocIterator pit = cpit;
+	pit.push_back(CursorSlice(const_cast<InsetBranch &>(*this)));
+
+	Toc & toc = buffer().tocBackend().toc("branch");
+	docstring str = params_.branch + ": ";
+	text().forToc(str, TOC_ENTRY_LENGTH);
+	toc.push_back(TocItem(pit, 0, str, toolTipText(docstring(), 3, 60)));
+	// Proceed with the rest of the inset.
+	InsetCollapsable::addToToc(cpit);
 }
 
 
 void InsetBranchParams::write(ostream & os) const
 {
-	os << "Branch " << to_utf8(branch) << '\n';
+	os << to_utf8(branch);
 }
 
 
 void InsetBranchParams::read(Lexer & lex)
 {
-	lex >> branch;
+	lex.eatLine();
+	branch = lex.getDocString();
 }
 
 } // namespace lyx