X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetBranch.cpp;h=2676d93338855498c7ae18d5f2ef114068537119;hb=73368ed2d97728ee3ec889383b3803d8e3309e9d;hp=33397b71aaf43354a00cd5cc2d9be7727d0ea4d4;hpb=7677e9487c1669735a2aa9b2356199c2f608fe15;p=lyx.git diff --git a/src/insets/InsetBranch.cpp b/src/insets/InsetBranch.cpp index 33397b71aa..2676d93338 100644 --- a/src/insets/InsetBranch.cpp +++ b/src/insets/InsetBranch.cpp @@ -16,19 +16,24 @@ #include "BufferParams.h" #include "BufferView.h" #include "BranchList.h" -#include "Color.h" +#include "ColorSet.h" #include "Counters.h" #include "Cursor.h" #include "DispatchResult.h" #include "FuncRequest.h" #include "FuncStatus.h" #include "Lexer.h" +#include "LyX.h" #include "OutputParams.h" +#include "output_xhtml.h" #include "TextClass.h" +#include "TocBackend.h" #include "support/debug.h" #include "support/gettext.h" +#include "support/lstrings.h" +#include "frontends/alert.h" #include "frontends/Application.h" #include @@ -38,26 +43,16 @@ using namespace std; namespace lyx { -InsetBranch::InsetBranch(Buffer const & buf, InsetBranchParams const & params) - : InsetCollapsable(buf), params_(params) +InsetBranch::InsetBranch(Buffer * buf, InsetBranchParams const & params) + : InsetCollapsable(buf, InsetText::DefaultLayout), params_(params) {} -InsetBranch::~InsetBranch() -{ - hideDialogs("branch", this); -} - - -docstring InsetBranch::editMessage() const -{ - return _("Opened Branch Inset"); -} - - void InsetBranch::write(ostream & os) const { + os << "Branch "; params_.write(os); + os << '\n'; InsetCollapsable::write(os); } @@ -69,88 +64,123 @@ void InsetBranch::read(Lexer & lex) } -docstring InsetBranch::toolTip(BufferView const &, int, int) const +docstring InsetBranch::toolTip(BufferView const & bv, int, int) const { - return _("Branch: ") + params_.branch; + 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::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() == InsetLayout::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); + if (decoration() == InsetLayout::CLASSIC) + return symb + (isOpen(bv) ? s : getNewLabel(s)); else - setLabel(params_.branch + ": " + getNewLabel(s)); + return symb + params_.branch + ": " + getNewLabel(s); } -ColorCode InsetBranch::backgroundColor() const +ColorCode InsetBranch::backgroundColor(PainterInfo const & pi) 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(); -} - - -bool InsetBranch::showInsetDialog(BufferView * bv) const -{ - bv->showDialog("branch", params2string(params()), - const_cast(this)); - 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; 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(); + 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().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_INSET_DIALOG_UPDATE: - cur.bv().updateDialog("branch", params2string(params())); + } + 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()) { - 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; @@ -165,23 +195,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()) - 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: @@ -191,50 +239,37 @@ bool InsetBranch::getStatus(Cursor & cur, FuncRequest const & cmd, } -bool InsetBranch::isBranchSelected() 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 = - 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(ParIterator const & it) -{ - if (isBranchSelected()) - InsetCollapsable::updateLabels(it); - else { - DocumentClass const & tclass = buffer().params().documentClass(); - Counters savecnt = tclass.counters(); - InsetCollapsable::updateLabels(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(odocstream & os, OutputParams const & runparams) const +void InsetBranch::latex(otexstream & os, OutputParams const & runparams) const { - return isBranchSelected() ? InsetText::latex(os, runparams) : 0; + if (isBranchSelected()) + InsetText::latex(os, runparams); } -int InsetBranch::plaintext(odocstream & os, - OutputParams const & runparams) const +int InsetBranch::plaintext(odocstringstream & os, + OutputParams const & runparams, size_t max_length) const { if (!isBranchSelected()) return 0; - os << '[' << buffer().B_("branch") << ' ' << params_.branch << ":\n"; - InsetText::plaintext(os, runparams); - os << "\n]"; - - return PLAINTEXT_NEWLINE + 1; // one char on a separate line + int len = InsetText::plaintext(os, runparams, max_length); + return len; } @@ -245,16 +280,42 @@ int InsetBranch::docbook(odocstream & os, } -void InsetBranch::textString(odocstream & os) const +docstring InsetBranch::xhtml(XHTMLStream & xs, OutputParams const & rp) const +{ + if (isBranchSelected()) { + OutputParams newrp = rp; + newrp.par_begin = 0; + newrp.par_end = text().paragraphs().size(); + xhtmlParagraphs(text(), buffer(), xs, newrp); + } + return docstring(); +} + + +void InsetBranch::toString(odocstream & os) const { if (isBranchSelected()) - os << paragraphs().begin()->asString(true); + InsetCollapsable::toString(os); +} + + +void InsetBranch::forToc(docstring & os, size_t maxlen) const +{ + if (isBranchSelected()) + InsetCollapsable::forToc(os, maxlen); } void InsetBranch::validate(LaTeXFeatures & features) const { - InsetText::validate(features); + if (isBranchSelected()) + InsetCollapsable::validate(features); +} + + +string InsetBranch::contextMenuName() const +{ + return "context-branch"; } @@ -268,7 +329,6 @@ bool InsetBranch::isMacroScope() const string InsetBranch::params2string(InsetBranchParams const & params) { ostringstream data; - data << "branch" << ' '; params.write(data); return data.str(); } @@ -283,38 +343,36 @@ void InsetBranch::string2params(string const & in, InsetBranchParams & params) istringstream data(in); Lexer lex; lex.setStream(data); + lex.setContext("InsetBranch::string2params"); + params.read(lex); +} - string name; - lex >> name; - if (name != "branch") { - LYXERR0("InsetBranch::string2params(" << in << ")\n" - "Expected arg 1 to be \"branch\"\n"); - return; - } - // This is part of the inset proper that is usually swallowed - // by Text::readInset - string id; - lex >> id; - if (!lex || id != "Branch") { - LYXERR0("InsetBranch::string2params(" << in << ")\n" - "Expected arg 2 to be \"Branch\"\n"); - return; - } - - params.read(lex); +void InsetBranch::addToToc(DocIterator const & cpit, bool output_active) const +{ + DocIterator pit = cpit; + pit.push_back(CursorSlice(const_cast(*this))); + + Toc & toc = buffer().tocBackend().toc("branch"); + docstring str = params_.branch + ": "; + text().forToc(str, TOC_ENTRY_LENGTH); + toc.push_back(TocItem(pit, 0, str, output_active, toolTipText(docstring(), 3, 60))); + // Proceed with the rest of the inset. + bool const doing_output = output_active && isBranchSelected(); + InsetCollapsable::addToToc(cpit, doing_output); } 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