X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetInfo.cpp;h=2c3943effdb643f1a62aad49c19257553070885b;hb=f5123ccfa82215030c70561af881175d92244492;hp=b41ad64843a16739f310df1d415f8b3c6a3e4ee3;hpb=f847e0776b4437d2f4d27e2f7f83028c9db2b02a;p=lyx.git

diff --git a/src/insets/InsetInfo.cpp b/src/insets/InsetInfo.cpp
index b41ad64843..2c3943effd 100644
--- a/src/insets/InsetInfo.cpp
+++ b/src/insets/InsetInfo.cpp
@@ -11,98 +11,115 @@
 
 #include "InsetInfo.h"
 
-#include <sstream>
-#include <stack>
-
+#include "Buffer.h"
 #include "BufferParams.h"
 #include "BufferView.h"
-#include "debug.h"
+#include "CutAndPaste.h"
 #include "FuncRequest.h"
-#include "gettext.h"
+#include "FuncStatus.h"
+#include "InsetGraphics.h"
 #include "InsetSpecialChar.h"
 #include "KeyMap.h"
 #include "LaTeXFeatures.h"
+#include "LayoutFile.h"
 #include "LyXAction.h"
 #include "LyXRC.h"
+#include "LyXVC.h"
 #include "Lexer.h"
-#include "MenuBackend.h"
-#include "MetricsInfo.h"
 #include "ParagraphParameters.h"
-#include "TextClassList.h"
-#include "support/lstrings.h"
+
+#include "frontends/Application.h"
+
+#include "support/debug.h"
+#include "support/docstream.h"
+#include "support/docstring_list.h"
 #include "support/ExceptionMessage.h"
+#include "support/FileName.h"
+#include "support/filetools.h"
+#include "support/gettext.h"
+#include "support/lstrings.h"
+
+#include <sstream>
 
-using std::pair;
-using std::string;
-using std::ostream;
-using std::ostringstream;
-using std::stack;
+using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
 
-using support::prefixIs;
-using support::trim;
-using support::split;
-using support::rtrim;
-using support::ExceptionMessage;
-using support::WarningException;
+namespace {
+
+typedef Translator<InsetInfo::info_type, string> NameTranslator;
+
+NameTranslator const initTranslator()
+{	
+	NameTranslator translator(InsetInfo::UNKNOWN_INFO, "unknown");
+
+	translator.addPair(InsetInfo::SHORTCUTS_INFO, "shortcuts");
+	translator.addPair(InsetInfo::SHORTCUT_INFO, "shortcut");
+	translator.addPair(InsetInfo::LYXRC_INFO, "lyxrc");
+	translator.addPair(InsetInfo::PACKAGE_INFO, "package");
+	translator.addPair(InsetInfo::TEXTCLASS_INFO, "textclass");
+	translator.addPair(InsetInfo::MENU_INFO, "menu");
+	translator.addPair(InsetInfo::ICON_INFO, "icon");
+	translator.addPair(InsetInfo::BUFFER_INFO, "buffer");
+	translator.addPair(InsetInfo::LYX_INFO, "lyxinfo");
+
+	return translator;
+}
+
+/// The translator between the information type enum and corresponding string.
+NameTranslator const & nameTranslator()
+{
+	static NameTranslator const translator = initTranslator();
+	return translator;
+}
+
+} // namespace anon
+
+/////////////////////////////////////////////////////////////////////////
+//
+// InsetInfo
+//
+/////////////////////////////////////////////////////////////////////////
+
 
-InsetInfo::InsetInfo(BufferParams const & bp, string const & name) 
-	: InsetText(bp), bp_(bp), type_(UNKNOWN_INFO), name_(),
-	  mouse_hover_(false)
+	
+InsetInfo::InsetInfo(Buffer * buf, string const & name) 
+	: InsetCollapsable(buf), type_(UNKNOWN_INFO), name_()
 {
 	setAutoBreakRows(true);
-	setDrawFrame(true);
 	setInfo(name);
+	status_ = Collapsed;
 }
 
 
 Inset * InsetInfo::editXY(Cursor & cur, int x, int y)
 {
-	return this;
+	// do not allow the cursor to be set in this Inset
+	return Inset::editXY(cur, x, y);
 }
 
 
-void InsetInfo::draw(PainterInfo & pi, int x, int y) const
+string InsetInfo::infoType() const
 {
-	InsetText::draw(pi, x, y); 
-	if (mouse_hover_) {
-		odocstringstream os;
-		os << _("Information regarding ")
-		   <<_(nameTranslator().find(type_))
-		   << _(" ") << from_utf8(name_);
-		pi.base.bv->message(os.str());
-	}
+	return nameTranslator().find(type_);
 }
 
 
-namespace {
-
-Translator<InsetInfo::info_type, string> const initTranslator()
-{	
-	Translator<InsetInfo::info_type, string> translator(InsetInfo::UNKNOWN_INFO, "unknown");
-
-	translator.addPair(InsetInfo::SHORTCUT_INFO, "shortcut");
-	translator.addPair(InsetInfo::LYXRC_INFO, "lyxrc");
-	translator.addPair(InsetInfo::PACKAGE_INFO, "package");
-	translator.addPair(InsetInfo::TEXTCLASS_INFO, "textclass");
-	translator.addPair(InsetInfo::MENU_INFO, "menu");
-
-	return translator;
+docstring InsetInfo::name() const 
+{
+	return from_ascii("Info:" + infoType());
 }
 
-} // namespace anon
 
-Translator<InsetInfo::info_type, std::string> const & InsetInfo::nameTranslator() const
+docstring InsetInfo::toolTip(BufferView const &, int, int) const
 {
-	static Translator<info_type, string> const translator =
-		initTranslator();
-	return translator;
+	return bformat(_("Information regarding %1$s '%2$s'"),
+			_(infoType()), from_utf8(name_));
 }
 
-	
 
-void InsetInfo::read(Buffer const & buf, Lexer & lex)
+void InsetInfo::read(Lexer & lex)
 {
 	string token;
 	while (lex.isOK()) {
@@ -113,7 +130,7 @@ void InsetInfo::read(Buffer const & buf, Lexer & lex)
 			token = lex.getString();
 			type_ = nameTranslator().find(token);
 		} else if (token == "arg") {
-			lex.next();
+			lex.next(true);
 			name_ = lex.getString();
 		} else if (token == "\\end_inset")
 			break;
@@ -128,29 +145,111 @@ void InsetInfo::read(Buffer const & buf, Lexer & lex)
 }
 
 
-void InsetInfo::write(Buffer const & buf, std::ostream & os) const
+void InsetInfo::write(ostream & os) const
+{
+	os << "Info\ntype  \"" << infoType() 
+	   << "\"\narg   " << Lexer::quoteString(name_);
+}
+
+
+bool InsetInfo::validateModifyArgument(docstring const & arg) const
+{
+	string type;
+	string const name = trim(split(to_utf8(arg), type, ' '));
+
+	switch (nameTranslator().find(type)) {
+	case UNKNOWN_INFO:
+		return false;
+
+	case SHORTCUT_INFO:
+	case SHORTCUTS_INFO:
+	case MENU_INFO:
+	case ICON_INFO: {
+		FuncRequest func = lyxaction.lookupFunc(name);
+		return func.action() != LFUN_UNKNOWN_ACTION;
+	}
+
+	case LYXRC_INFO: {
+		ostringstream oss;
+		lyxrc.write(oss, true, name);
+		return !oss.str().empty();
+	}
+
+	case PACKAGE_INFO:
+	case TEXTCLASS_INFO:
+		return true;
+
+	case BUFFER_INFO:
+		if (name == "name" || name == "path" || name == "class")
+			return true;
+		if (name == "vcs-revision" || name == "vcs-tree-revision" ||
+		       name == "vcs-author" || name == "vcs-date" || name == "vcs-time")
+			return buffer().lyxvc().inUse();
+		return false;
+
+	case LYX_INFO:
+		return name == "version";
+	}
+
+	return false;
+}
+
+
+bool InsetInfo::showInsetDialog(BufferView * bv) const
 {
-	os << "Info\ntype  \""
-	   << nameTranslator().find(type_)
-	   << "\"\narg   \"" << name_ << '\"';
+	bv->showDialog("info");
+	return true;
+}
+
+
+bool InsetInfo::getStatus(Cursor & cur, FuncRequest const & cmd,
+		FuncStatus & flag) const
+{
+	switch (cmd.action()) {
+	case LFUN_INSET_SETTINGS:
+		return InsetCollapsable::getStatus(cur, cmd, flag);
+		
+	case LFUN_INSET_DIALOG_UPDATE:
+	case LFUN_INSET_COPY_AS:
+		flag.setEnabled(true);
+		return true;
+		
+	case LFUN_INSET_MODIFY:
+		if (validateModifyArgument(cmd.argument())) {
+			flag.setEnabled(true);
+			return true;
+		}
+		//fall through
+		
+	default:
+		return false;
+	}
 }
 
 
 void InsetInfo::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
-	// FIXME: we should allow selection, copy etc...
-	switch (cmd.action) {
-	case LFUN_MOUSE_PRESS:
-	case LFUN_MOUSE_RELEASE:
-	case LFUN_MOUSE_MOTION:
-	case LFUN_MOUSE_DOUBLE:
-	case LFUN_MOUSE_TRIPLE:
-		// do not dispatch to InsetText
-		cur.dispatched();
+	switch (cmd.action()) {
+	case LFUN_INSET_MODIFY:
+		setInfo(to_utf8(cmd.argument()));
 		break;
 
+	case LFUN_INSET_COPY_AS: {
+		cap::clearSelection();
+		Cursor copy(cur);
+		copy.pushBackward(*this);
+		copy.pit() = 0;
+		copy.pos() = 0;
+		copy.resetAnchor();
+		copy.pit() = copy.lastpit();
+		copy.pos() = copy.lastpos();
+		copy.setSelection();
+		cap::copySelection(copy);
+		break;
+	}
+
 	default:
-		InsetText::doDispatch(cur, cmd);
+		InsetCollapsable::doDispatch(cur, cmd);
 		break;
 	}
 }
@@ -168,85 +267,194 @@ void InsetInfo::setInfo(string const & name)
 }
 
 
+void InsetInfo::error(string const & err)
+{
+	setText(bformat(_(err), from_utf8(name_)), 
+		Font(inherit_font, buffer().params().language), false);
+}
+
+
+void InsetInfo::setText(docstring const & str)
+{
+	setText(str, Font(inherit_font, buffer().params().language), false);
+}
+
+
 void InsetInfo::updateInfo()
 {
-	InsetText::clear();
+	BufferParams const & bp = buffer().params();	
 
 	switch (type_) {
 	case UNKNOWN_INFO:
-		setText(_("Unknown Info: ") + from_utf8(name_),
-			bp_.getFont(), false);
+		error("Unknown Info: %1$s");
 		break;
-	case SHORTCUT_INFO: {
-		FuncRequest func = lyxaction.lookupFunc(name_);
-		if (func.action != LFUN_UNKNOWN_ACTION)
-			setText(theTopLevelKeymap().printbindings(func),
-				bp_.getFont(), false);
+	case SHORTCUT_INFO:
+	case SHORTCUTS_INFO: {
+		FuncRequest const func = lyxaction.lookupFunc(name_);
+		if (func.action() == LFUN_UNKNOWN_ACTION) {
+			error("Unknown action %1$s");
+			break;
+		}
+		KeyMap::Bindings bindings = theTopLevelKeymap().findBindings(func);
+		if (bindings.empty()) {
+			// It is impropriate to use error() for undefined shortcut
+			setText(_("undefined"));
+			break;
+		}
+		if (type_ == SHORTCUT_INFO)
+			setText(bindings.begin()->print(KeySequence::Portable));
+		else
+			setText(theTopLevelKeymap().printBindings(func, KeySequence::Portable));
 		break;
 	}
 	case LYXRC_INFO: {
 		ostringstream oss;
+		if (name_.empty()) {
+			setText(_("undefined"));
+			break;
+		}
 		lyxrc.write(oss, true, name_);
 		string result = oss.str();
-		// remove leading \\name
-		result = result.substr(name_.size() + 2);
+		if (result.size() < 2) {
+			setText(_("undefined"));
+			break;
+		}
+		string::size_type loc = result.rfind("\n", result.size() - 2);
+		loc = loc == string::npos ? 0 : loc + 1;
+		if (result.size() < loc + name_.size() + 1
+			  || result.substr(loc + 1, name_.size()) != name_) {
+			setText(_("undefined"));
+			break;
+		}
+		// remove leading comments and \\name and space
+		result = result.substr(loc + name_.size() + 2);
+		
 		// remove \n and ""
 		result = rtrim(result, "\n");
 		result = trim(result, "\"");
-		setText(from_utf8(result), bp_.getFont(), false);
+		setText(from_utf8(result));
 		break;
 	}
 	case PACKAGE_INFO:
 		// check in packages.lst
-		setText(LaTeXFeatures::isAvailable(name_) ? _("yes") : _("no"),
-			bp_.getFont(), false);
+		setText(LaTeXFeatures::isAvailable(name_) ? _("yes") : _("no"));
 		break;
+
 	case TEXTCLASS_INFO: {
 		// name_ is the class name
-		pair<bool, lyx::textclass_type> pp =
-			textclasslist.numberOfClass(name_);
-		setText(pp.first ? _("yes") : _("no"),
-			bp_.getFont(), false);
+		LayoutFileList const & list = LayoutFileList::get();
+		bool available = false;
+		if (list.haveClass(name_))
+			available = list[name_].isTeXClassAvailable();
+		setText(available ? _("yes") : _("no"));
 		break;
 	}
 	case MENU_INFO: {
-		stack<docstring> names;
-		FuncRequest func = lyxaction.lookupFunc(name_);
-		if (func.action == LFUN_UNKNOWN_ACTION) {
-			setText(_("No menu entry for "), bp_.getFont(), false);
+		docstring_list names;
+		FuncRequest const func = lyxaction.lookupFunc(name_);
+		if (func.action() == LFUN_UNKNOWN_ACTION) {
+			error("Unknown action %1$s");
 			break;
 		}
 		// iterate through the menubackend to find it
-		Menu menu = menubackend.getMenubar();
-		if (!menu.searchFunc(func, names)) {
-			setText(_("No menu entry for "), bp_.getFont(), false);
+		if (!theApp()->searchMenu(func, names)) {
+			error("No menu entry for action %1$s");
 			break;
 		}
-		// if find, return its path.
-		InsetText::clear();
-		Paragraph & info = paragraphs().front();
-		unsigned int i = 0;
-		while (!names.empty()) {
+		// if found, return its path.
+		clear();
+		Paragraph & par = paragraphs().front();
+		Font const f(inherit_font, buffer().params().language);
+		//Font fu = f;
+		//fu.fontInfo().setUnderbar(FONT_ON);
+		docstring_list::const_iterator beg = names.begin();
+		docstring_list::const_iterator end = names.end();
+		for (docstring_list::const_iterator it = beg ; 
+		     it != end ; ++it) {
 			// do not insert > for the top level menu item
-			if (i != 0)
-				info.insertInset(0, new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR),
-					Change(Change::UNCHANGED));
-			for (i = 0; i < names.top().length(); ++i)
-				info.insertChar(i, names.top()[i], bp_.getFont(), false);
-			names.pop();
+			if (it != beg)
+				par.insertInset(par.size(), new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR),
+						Change(Change::UNCHANGED));
+			//FIXME: add proper underlines here. This
+			// involves rewriting searchMenu used above to
+			// return a vector of menus. If we do not do
+			// that, we might as well use below
+			// Paragraph::insert on each string (JMarc)
+			for (size_type i = 0; i != it->length(); ++i)
+				par.insertChar(par.size(), (*it)[i], 
+					       f, Change(Change::UNCHANGED));
 		}
 		break;
 	}
+	case ICON_INFO: {
+		FuncRequest func = lyxaction.lookupFunc(name_);
+		docstring icon_name = theApp()->iconName(func, true);
+		//FIXME: We should use the icon directly instead of
+		// going through FileName. The code below won't work
+		// if the icon is embedded in the executable through
+		// the Qt resource system.
+		FileName file(to_utf8(icon_name));
+		if (!file.exists())
+			break;
+		InsetGraphics * inset = new InsetGraphics(buffer_);
+		InsetGraphicsParams igp;
+		igp.filename = file;
+		inset->setParams(igp);
+		clear();
+		paragraphs().front().insertInset(0, inset, 
+						 Change(Change::UNCHANGED));
+		break;
+	}
+	case BUFFER_INFO: {
+		if (name_ == "name") {
+			setText(from_utf8(buffer().fileName().onlyFileName()));
+			break;
+		}
+		if (name_ == "path") {
+			setText(from_utf8(buffer().filePath()));
+			break;
+		}
+		if (name_ == "class") {
+			setText(from_utf8(bp.documentClass().name()));
+			break;
+		}
+		
+		// everything that follows is for version control.
+		// nothing that isn't version control should go below this line.
+		if (!buffer().lyxvc().inUse()) {
+			setText(_("No version control"));
+			break;
+		}
+		LyXVC::RevisionInfo itype = LyXVC::Unknown;
+		if (name_ == "vcs-revision")
+			itype = LyXVC::File;
+		else if (name_ == "vcs-tree-revision")
+			itype = LyXVC::Tree;
+		else if (name_ == "vcs-author")
+			itype = LyXVC::Author;
+		else if (name_ == "vcs-time")
+			itype = LyXVC::Time;
+		else if (name_ == "vcs-date")
+			itype = LyXVC::Date;
+		string binfo = buffer().lyxvc().revisionInfo(itype);
+		if (binfo.empty())
+			setText(bformat(_("%1$s unknown"), from_ascii(name_)));
+		else
+			setText(from_utf8(binfo));
+		break;
+	}
+	case LYX_INFO:
+		if (name_ == "version")
+			setText(from_ascii(PACKAGE_VERSION));
+		break;
 	}
-	// remove indent
-	paragraphs().begin()->params().noindent(true);
 }
 
 
-bool InsetInfo::setMouseHover(bool mouse_hover)
+docstring InsetInfo::contextMenu(BufferView const &, int, int) const
 {
-	mouse_hover_ = mouse_hover;
-	return true;
+	return from_ascii("context-info");
 }
 
+
 } // namespace lyx