X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=c76ebbdd9ccf82295d657bb4c23415bf1232df5d;hb=8b8741cd5d7e960c5663911f8b69972419f6d37b;hp=8253912947af2f37060692733803c597a3da0b41;hpb=7fdf62dd8ed3771d17253822fc1722144ab8b4e5;p=lyx.git

diff --git a/src/lyxfunc.C b/src/lyxfunc.C
index 8253912947..c76ebbdd9c 100644
--- a/src/lyxfunc.C
+++ b/src/lyxfunc.C
@@ -158,9 +158,6 @@ MiniBufferController mb_ctrl;
 
 /* === globals =========================================================== */
 
-// Initialization of static member var
-bool LyXFunc::show_sc = true;
-
 
 LyXFunc::LyXFunc(LyXView * o)
 	: owner(o),
@@ -325,49 +322,40 @@ void LyXFunc::processKeySym(KeySym keysym, unsigned int state)
 	if (action == LFUN_SELFINSERT) {
 		// This is very X dependent.
 		unsigned int c = keysym;
+		string argument;
 		
 		c = kb_keymap::getiso(c);
 
 		if (c > 0)
 			argument = static_cast<char>(c);
+		
+		dispatch(LFUN_SELFINSERT, argument);
 		lyxerr[Debug::KEY] << "SelfInsert arg[`"
 				   << argument << "']" << endl;
 	}
-	
-        bool tmp_sc = show_sc;
-	show_sc = false;
-	dispatch(action, argument);
-	show_sc = tmp_sc;
-	
-	//return 0;
+	else
+		verboseDispatch(action, false);
 } 
 
 
-func_status::value_type LyXFunc::getStatus(int ac) const
+FuncStatus LyXFunc::getStatus(int ac) const
 {
-	return getStatus(ac, string());
+	kb_action action;
+	string argument;
+	action = lyxaction.retrieveActionArg(ac, argument);
+	return getStatus(action, argument);
 }
 
 
-func_status::value_type LyXFunc::getStatus(int ac,
-					   string const & not_to_use_arg) const
+FuncStatus LyXFunc::getStatus(kb_action action,
+			      string const & argument) const
 {
-	kb_action action;
-	func_status::value_type flag = func_status::OK;
-	string argument;
+	FuncStatus flag;
 	Buffer * buf = owner->buffer();
 	
-	if (lyxaction.isPseudoAction(ac)) 
-		action = lyxaction.retrieveActionArg(ac, argument);
-	else {
-		action = static_cast<kb_action>(ac);
-		if (!not_to_use_arg.empty())
-			argument = not_to_use_arg; // exept here
-	}
-	
 	if (action == LFUN_UNKNOWN_ACTION) {
 		setErrorMessage(N_("Unknown action"));
-		return func_status::Unknown;
+		return flag.unknown(true);
 	}
 	
 	// Check whether we need a buffer
@@ -381,14 +369,13 @@ func_status::value_type LyXFunc::getStatus(int ac,
 						   LyXAction::ReadOnly)) {
 				// no
 				setErrorMessage(N_("Document is read-only"));
-				flag |= func_status::Disabled;
+				flag.disabled(true);
 			}
 		} else {
 			// no
 			setErrorMessage(N_("Command not allowed with"
 					   "out any document open"));
-			flag |= func_status::Disabled;
-			return flag;
+			return flag.disabled(true);
 		}
 	}
 
@@ -436,7 +423,8 @@ func_status::value_type LyXFunc::getStatus(int ac,
 	case LFUN_TABULAR_FEATURE:
 		disable = true;
 		if (owner->view()->theLockingInset()) {
-			func_status::value_type ret = func_status::Disabled;
+			FuncStatus ret;
+			//ret.disabled(true);
 			if (owner->view()->theLockingInset()->lyxCode() == Inset::TABULAR_CODE) {
 				ret = static_cast<InsetTabular *>
 					(owner->view()->theLockingInset())->
@@ -451,13 +439,11 @@ func_status::value_type LyXFunc::getStatus(int ac,
 			disable = false;
 		} else {
 			static InsetTabular inset(*owner->buffer(), 1, 1);
-			func_status::value_type ret;
+			FuncStatus ret;
 
 			disable = true;
 			ret = inset.getStatus(argument);
-			if ((ret & func_status::ToggleOn) ||
-			    (ret & func_status::ToggleOff))
-				flag |= func_status::ToggleOff;
+			if (ret.onoff(true) || ret.onoff(false)) flag.setOnOff(false);
 		}
 		break;
 
@@ -499,17 +485,14 @@ func_status::value_type LyXFunc::getStatus(int ac,
 				break;
 			}
 			if (argument.empty()) {
-				flag = func_status::OK;
+				flag.clear();
 				break;
 			}
 			if (!contains("tcb", argument[0])) {
 				disable = true;
 				break;
 			}
-			if (argument[0] == align) 
-				flag |= func_status::ToggleOn;
-			else
-				flag |= func_status::ToggleOff;
+			flag.setOnOff(argument[0] == align);
 		} else
 			disable = true;
 		break;
@@ -525,17 +508,14 @@ func_status::value_type LyXFunc::getStatus(int ac,
 				break;
 			}
 			if (argument.empty()) {
-				flag = func_status::OK;
+				flag.clear();
 				break;
 			}
 			if (!contains("lcr", argument[0])) {
 				disable = true;
 				break;
 			}
-			if (argument[0] == align) 
-				flag |= func_status::ToggleOn;
-			else
-				flag |= func_status::ToggleOff;
+			flag.setOnOff(argument[0] == align);
 		} else
 			disable = true;
 		break;
@@ -544,24 +524,17 @@ func_status::value_type LyXFunc::getStatus(int ac,
 		Inset * tli = owner->view()->theLockingInset();
 		if (tli && (tli->lyxCode() == Inset::MATH_CODE)) {
 			MathInsetTypes type = mathcursor->formula()->getType();
-			func_status::value_type box = func_status::ToggleOff;
 			if (argument == "inline") {
-				if (type == LM_OT_SIMPLE)
-					box = func_status::ToggleOn;
+				flag.setOnOff(type == LM_OT_SIMPLE);
 			} else if (argument == "display") {
-				if (type == LM_OT_EQUATION)
-					box = func_status::ToggleOn;
+				flag.setOnOff(type == LM_OT_EQUATION);
 			} else if (argument == "eqnarray") {
-				if (type == LM_OT_EQNARRAY)
-					box = func_status::ToggleOn;
+				flag.setOnOff(type == LM_OT_EQNARRAY);
 			} else if (argument == "align") {
-				if (type == LM_OT_ALIGN)
-					box = func_status::ToggleOn;
+				flag.setOnOff(type == LM_OT_ALIGN);
 			} else {
-				box = func_status::OK;
 				disable = true;
 			}
-			flag |= box;
 		} else
 			disable = true;
 		break;
@@ -573,8 +546,6 @@ func_status::value_type LyXFunc::getStatus(int ac,
 	case LFUN_MATH_LIMITS: 
 	case LFUN_MATH_NONUMBER: 
 	case LFUN_MATH_NUMBER:
-	case LFUN_SUBSCRIPT:
-	case LFUN_SUPERSCRIPT:
 		disable = !mathcursor;
 		break;
 
@@ -699,39 +670,75 @@ func_status::value_type LyXFunc::getStatus(int ac,
 	}
 
 	if (disable)
-	        flag |= func_status::Disabled;
+			flag.disabled(true);
 	
-	// the font related functions (and a few others)
-	func_status::value_type box = func_status::ToggleOff;
-	LyXFont const & font =
-		TEXT(false)->real_current_font;
+	// A few general toggles
 	switch (action) {
-	case LFUN_EMPH:
-		if (font.emph() == LyXFont::ON)
-			box = func_status::ToggleOn;
-		break;
-	case LFUN_NOUN:
-		if (font.noun() == LyXFont::ON)
-			box = func_status::ToggleOn;
-		break;
-	case LFUN_BOLD:
-		if (font.series() == LyXFont::BOLD_SERIES)
-			box = func_status::ToggleOn;
-		break;
 	case LFUN_READ_ONLY_TOGGLE:
-		if (buf->isReadonly())
-			box = func_status::ToggleOn;
+		flag.setOnOff(buf->isReadonly());
 		break;
 	case LFUN_APPENDIX:
-		if (TEXT(false)->cursor.par()->params().startOfAppendix())
-			box = func_status::ToggleOn;
+		flag.setOnOff(TEXT(false)->cursor.par()->params().startOfAppendix());
 		break;
 	default:
-		box = func_status::OK;
 		break;
 	}
-	flag |= box;
 
+	// the font related toggles
+	if (!mathcursor) {
+		LyXFont const & font = TEXT(false)->real_current_font;
+		switch (action) {
+		case LFUN_EMPH:
+			flag.setOnOff(font.emph() == LyXFont::ON);
+			break;
+		case LFUN_NOUN:
+			flag.setOnOff(font.noun() == LyXFont::ON);
+			break;
+		case LFUN_BOLD:
+			flag.setOnOff(font.series() == LyXFont::BOLD_SERIES);
+			break;
+		case LFUN_SANS:
+			flag.setOnOff(font.family() == LyXFont::SANS_FAMILY);
+			break;
+		case LFUN_ROMAN:
+			flag.setOnOff(font.family() == LyXFont::ROMAN_FAMILY);
+			break;
+		case LFUN_CODE:
+			flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY);
+			break;
+		default:
+			break;
+		}
+	}
+	else {
+		MathTextCodes tc = mathcursor->getLastCode();
+		switch (action) {
+		case LFUN_BOLD:
+			flag.setOnOff(tc == LM_TC_BF);
+			break;
+		case LFUN_SANS:
+			flag.setOnOff(tc == LM_TC_SF);
+			break;
+		case LFUN_EMPH:
+			flag.setOnOff(tc == LM_TC_CAL);
+			break;
+		case LFUN_ROMAN:
+			flag.setOnOff(tc == LM_TC_RM);
+			break;
+		case LFUN_CODE:
+			flag.setOnOff(tc == LM_TC_TT);
+			break;
+		case LFUN_NOUN:
+			flag.setOnOff(tc == LM_TC_BB);
+			break;
+		case LFUN_DEFAULT:
+			flag.setOnOff(tc == LM_TC_VAR);
+			break;
+		default:
+			break;
+		}
+	}
+	
 	return flag;
 }
 
@@ -739,48 +746,110 @@ func_status::value_type LyXFunc::getStatus(int ac,
 // temporary dispatch method
 void LyXFunc::miniDispatch(string const & s) 
 {
-	if (!s.empty()) {
-		dispatch(s);
+	string s2(frontStrip(strip(s))); 
+ 
+	if (!s2.empty()) {
+		verboseDispatch(s2, true);
 	}
 }
 
 
-string const LyXFunc::dispatch(string const & s) 
+void const LyXFunc::verboseDispatch(string const & s, bool show_sc) 
 {
 	// Split command string into command and argument
 	string cmd;
 	string line = frontStrip(s);
 	string const arg = strip(frontStrip(split(line, cmd, ' ')));
 
-	return dispatch(lyxaction.LookupFunc(cmd), arg);
+	int action = lyxaction.LookupFunc(cmd);
+ 
+	if (action == LFUN_UNKNOWN_ACTION) {
+		string const msg = string(_("Unknown function ("))
+			+ cmd + ")";
+		owner->message(msg);
+	} else {
+		verboseDispatch(action, show_sc);
+	} 
 }
 
 
-string const LyXFunc::dispatch(int ac,
-			       string const & do_not_use_this_arg)
+void const LyXFunc::verboseDispatch(int ac, bool show_sc) 
 {
-	lyxerr[Debug::ACTION] << "LyXFunc::Dispatch: action[" << ac
-			      <<"] arg[" << do_not_use_this_arg << "]" << endl;
-	
 	string argument;
 	kb_action action;
         
-        // we have not done anything wrong yet.
-        errorstat = false;
-	dispatch_buffer.erase();
+	// get the real action and argument
+	action = lyxaction.retrieveActionArg(ac, argument);
+
+	verboseDispatch(action, argument, show_sc);
+}
+
+
+
+void const LyXFunc::verboseDispatch(kb_action action,
+				    string const & argument, bool show_sc)
+{
+	string res = dispatch(action, argument);
+
+	commandshortcut.erase();
 	
-	// if action is a pseudo-action, we need the real action
-	if (lyxaction.isPseudoAction(ac)) {
-		string tmparg;
-		action = static_cast<kb_action>
-			(lyxaction.retrieveActionArg(ac, tmparg));
-		if (!tmparg.empty())
-			argument = tmparg;
+	if (lyxrc.display_shortcuts && show_sc) {
+		if (action != LFUN_SELFINSERT) {
+			// Put name of command and list of shortcuts
+			// for it in minibuffer
+			string comname = lyxaction.getActionName(action);
+			
+			int pseudoaction = action;
+			bool argsadded = false;
+			
+			if (!argument.empty()) {
+				// the pseudoaction is useful for the bindings
+				pseudoaction = 
+					lyxaction.searchActionArg(action,
+							  	  argument);
+
+				if (pseudoaction == LFUN_UNKNOWN_ACTION) {
+					pseudoaction = action;
+				} else {
+					comname += " " + argument;
+					argsadded = true;
+				}
+			}
+
+			string const shortcuts =
+				toplevel_keymap->findbinding(pseudoaction);
+
+			if (!shortcuts.empty()) {
+				comname += ": " + shortcuts;
+			} else if (!argsadded && !argument.empty()) {
+				comname += " " + argument;
+			}
+
+			if (!comname.empty()) {
+				comname = strip(comname);
+				commandshortcut = "(" + comname + ')';
+			}
+		}
+        }
+
+	if (res.empty()) {
+		if (!commandshortcut.empty()) {
+			owner->getMiniBuffer()->addSet(commandshortcut);
+		}
 	} else {
-		action = static_cast<kb_action>(ac);
-		if (!do_not_use_this_arg.empty())
-			argument = do_not_use_this_arg; // except here
+		owner->getMiniBuffer()->addSet(' ' + commandshortcut);
 	}
+}
+
+
+string const LyXFunc::dispatch(kb_action action, string argument)
+{
+	lyxerr[Debug::ACTION] << "LyXFunc::Dispatch: action[" << action
+			      <<"] arg[" << argument << "]" << endl;
+
+        // we have not done anything wrong yet.
+        errorstat = false;
+	dispatch_buffer.erase();
 
 #ifdef NEW_DISPATCHER
 	// We try do call the most specific dispatcher first:
@@ -788,17 +857,17 @@ string const LyXFunc::dispatch(int ac,
 	//  2. the bufferview's dispatch
 	//  3. the lyxview's dispatch
 #endif
-	
+
 	selection_possible = false;
-	
+
 	if (owner->view()->available())
 		owner->view()->hideCursor();
 
 	// We cannot use this function here
-	if (getStatus(ac, do_not_use_this_arg) & func_status::Disabled) {
+	if (getStatus(action, argument).disabled()) {
 		lyxerr[Debug::ACTION] << "LyXFunc::Dispatch: "
-		       << lyxaction.getActionName(ac)
-		       << " [" << ac << "] is disabled at this location"
+		       << lyxaction.getActionName(action)
+		       << " [" << action << "] is disabled at this location"
 		       << endl;
 		goto exit_with_message;
 	}
@@ -808,7 +877,8 @@ string const LyXFunc::dispatch(int ac,
 		if ((action > 1) || ((action == LFUN_UNKNOWN_ACTION) &&
 				     (!keyseq.deleted())))
 		{
-			if ((action==LFUN_UNKNOWN_ACTION) && argument.empty()){
+			if ((action == LFUN_UNKNOWN_ACTION)
+			    && argument.empty()){
 				argument = keyseq.getiso();
 			}
 			// Undo/Redo is a bit tricky for insets.
@@ -896,7 +966,6 @@ string const LyXFunc::dispatch(int ac,
 	case LFUN_ESCAPE:
 	{
 		if (!owner->view()->available()) break;
-		
 		// this function should be used always [asierra060396]
 		UpdatableInset * tli =
 			owner->view()->theLockingInset();
@@ -913,6 +982,7 @@ string const LyXFunc::dispatch(int ac,
 							lock,
 							true);
 			}
+			finishUndo();
 		}
 	}
 	break;
@@ -1400,13 +1470,19 @@ string const LyXFunc::dispatch(int ac,
 	case LFUN_MATH_NUMBER:
 	case LFUN_MATH_NONUMBER:
 	case LFUN_MATH_LIMITS:
-	case LFUN_SUBSCRIPT:
-	case LFUN_SUPERSCRIPT:
 	{
 		setErrorMessage(N_("This is only allowed in math mode!"));
 	}
 	break;
 
+	// passthrough hat and underscore outside mathed:
+	case LFUN_SUBSCRIPT:
+		dispatch(LFUN_SELFINSERT, "_");
+		break;
+	case LFUN_SUPERSCRIPT:
+		dispatch(LFUN_SELFINSERT, "^");
+		break;
+
 	case LFUN_MATH_PANEL:
 		owner->getDialogs()->showMathPanel();
 		break;
@@ -1473,7 +1549,7 @@ string const LyXFunc::dispatch(int ac,
 		while (argument.find(';') != string::npos) {
 			string first;
 			argument = split(argument, first, ';');
-			dispatch(first);
+			verboseDispatch(first, false);
 		}
 	}
 	break;
@@ -1552,65 +1628,10 @@ string const LyXFunc::dispatch(int ac,
 
 exit_with_message:
 
-	commandshortcut.erase();
-	
-	if (lyxrc.display_shortcuts && show_sc) {
-		if (action != LFUN_SELFINSERT) {
-			// Put name of command and list of shortcuts
-			// for it in minibuffer
-			string comname = lyxaction.getActionName(action);
-
-			kb_action pseudoaction = action;
-			bool argsadded = false;
-
-			if (!argument.empty()) {
-				// If we have the command with argument, 
-				// this is better
-				pseudoaction = 
-					lyxaction.searchActionArg(action,
-							  	  argument);
-
-				if (pseudoaction == -1) {
-					pseudoaction = action;
-				} else {
-					comname += " " + argument;
-					argsadded = true;
-				}
-			}
-
-			string const shortcuts =
-				toplevel_keymap->findbinding(pseudoaction);
-
-			if (!shortcuts.empty()) {
-				comname += ": " + shortcuts;
-			} else if (!argsadded) {
-				comname += " " + argument;
-			}
-
-			if (!comname.empty()) {
-				comname = strip(comname);
-				commandshortcut = "(" + comname + ')';
-
-				// Here we could even add a small pause,
-				// to annoy the user and make him learn
-				// the shortcuts.
-				// No! That will just annoy, not teach
-				// anything. The user will read the messages
-				// if they are interested. (Asger)
-			}
-		}
-        }
-
 	string const res = getMessage();
 
-	if (res.empty()) {
-		if (!commandshortcut.empty()) {
-			owner->getMiniBuffer()->addSet(commandshortcut);
-		}
-	} else {
-		string const msg(_(res) + ' ' + commandshortcut);
-		owner->message(msg);
-	}
+	if (!res.empty())
+		owner->message(_(res));
 
 	return res;
 }