X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbufferview_funcs.C;h=feec11d5e8e02cae6c9f11b1e73aca4eed7044c0;hb=0de182f2571c1ab327843cc281bc1f5302058e26;hp=8d68fc7456fe4aa18b9b89c606707880f52fb7b7;hpb=33f1a7576f909de4902546a9e67a454df7582139;p=lyx.git

diff --git a/src/bufferview_funcs.C b/src/bufferview_funcs.C
index 8d68fc7456..feec11d5e8 100644
--- a/src/bufferview_funcs.C
+++ b/src/bufferview_funcs.C
@@ -1,332 +1,414 @@
-/* This file is part of
- * ====================================================== 
- * 
- *           LyX, The Document Processor
- *        
- *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2000 The LyX Team.
+/**
+ * \file bufferview_funcs.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- * ====================================================== */
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author John Levon
+ * \author Angus Leeming
+ *
+ * Full author contact details are available in file CREDITS
+ */
 
 #include <config.h>
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
 #include "bufferview_funcs.h"
-#include "LyXView.h"
 #include "BufferView.h"
-#include "lyxparagraph.h"
+#include "paragraph.h"
 #include "lyxfont.h"
-#include "lyx_gui_misc.h"
+#include "lyxlex.h"
 #include "lyxtext.h"
-#include "minibuffer.h"
 #include "buffer.h"
-#include "support/lstrings.h"
 #include "lyx_cb.h"
-#include "layout_forms.h"
+#include "language.h"
+#include "gettext.h"
+#include "ParagraphParameters.h"
+#include "author.h"
+#include "changes.h"
 
-extern FD_form_paragraph * fd_form_paragraph;
-extern FD_form_character * fd_form_character;
+#include "frontends/LyXView.h"
+#include "frontends/Alert.h"
 
-#ifndef NEW_INSETS
-void Foot(BufferView * bv)
-{
-	if (!bv->available()) 
-		return;
-	
-	bv->owner()->getMiniBuffer()
-		->Set(_("Inserting Footnote..."));
-	bv->hideCursor();
-	bv->update(BufferView::SELECT|BufferView::FITCUR);
-	bv->text->InsertFootnoteEnvironment(bv, LyXParagraph::FOOTNOTE);
-	bv->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+#include "support/lstrings.h"
+#include "Lsstream.h"
+
+#include "insets/updatableinset.h"
+
+#include "BoostFormat.h"
+
+namespace {
+LyXFont freefont(LyXFont::ALL_IGNORE);
+bool toggleall(false);
 }
-#endif
 
 
-void Emph(BufferView * bv)
+// Set data using font and toggle
+// If successful, returns true
+bool font2string(LyXFont const & font, bool toggle, string & data)
 {
-	LyXFont font(LyXFont::ALL_IGNORE);
-	font.setEmph(LyXFont::TOGGLE);
-	ToggleAndShow(bv, font);
+	string lang = "ignore";
+	if (font.language())
+		lang = font.language()->lang();
+
+	ostringstream os;
+	os << "family " << font.family() << '\n'
+	   << "series " << font.series() << '\n'
+	   << "shape " << font.shape() << '\n'
+	   << "size " << font.size() << '\n'
+	   << "emph " << font.emph() << '\n'
+	   << "underbar " << font.underbar() << '\n'
+	   << "noun " << font.noun() << '\n'
+	   << "number " << font.number() << '\n'
+	   << "color " << font.color() << '\n'
+	   << "language " << lang << '\n'
+	   << "toggleall " << tostr(toggle);
+	data = os.str();
+	return true;
 }
 
 
-void Bold(BufferView * bv)
+// Set font and toggle using data
+// If successful, returns true
+bool string2font(string const & data, LyXFont & font, bool & toggle)
 {
-	LyXFont font(LyXFont::ALL_IGNORE);
-	font.setSeries(LyXFont::BOLD_SERIES);
-	ToggleAndShow(bv, font);
+	istringstream is(data);
+	LyXLex lex(0,0);
+	lex.setStream(is);
+
+	int Int = 0;
+	bool Bool = false;
+	string String;
+			
+	int nset = 0;
+	while (lex.isOK()) {
+		lex.next();
+		string const token = lex.getString();
+
+		if (token == "family" ||
+		    token == "series" ||
+		    token == "shape" ||
+		    token == "size" ||
+		    token == "emph" ||
+		    token == "underbar" ||
+		    token == "noun" ||
+		    token == "number" ||
+		    token == "color") {
+			lex.next();
+			Int = lex.getInteger();
+		} else if (token == "language") {
+			lex.next();
+			String = lex.getString();
+		} else if (token == "toggleall") {
+			lex.next();
+			Bool = lex.getBool();
+		} else {
+			// Unrecognised token
+			break;
+		}
+
+		if (!lex.isOK())
+			break;
+		++nset;
+
+		if (token == "family") {
+			font.setFamily(static_cast<LyXFont::FONT_FAMILY>(Int));
+			
+		} else if (token == "series") {
+			font.setSeries(static_cast<LyXFont::FONT_SERIES>(Int));
+
+		} else if (token == "shape") {
+			font.setShape(static_cast<LyXFont::FONT_SHAPE>(Int));
+
+		} else if (token == "size") {
+			font.setSize(static_cast<LyXFont::FONT_SIZE>(Int));
+
+		} else if (token == "emph") {
+			font.setEmph(static_cast<LyXFont::FONT_MISC_STATE>(Int));
+
+		} else if (token == "underbar") {
+			font.setUnderbar(static_cast<LyXFont::FONT_MISC_STATE>(Int));
+
+		} else if (token == "noun") {
+			font.setNoun(static_cast<LyXFont::FONT_MISC_STATE>(Int));
+
+		} else if (token == "number") {
+			font.setNumber(static_cast<LyXFont::FONT_MISC_STATE>(Int));
+
+		} else if (token == "color") {
+			font.setColor(static_cast<LColor::color>(Int));
+
+		} else if (token == "language") {
+			if (String == "ignore")
+				font.setLanguage(ignore_language);
+			else
+				font.setLanguage(languages.getLanguage(String));
+
+		} else if (token == "toggleall") {
+			toggle = Bool;
+		}
+	}
+	return (nset > 0);
 }
 
 
-void Noun(BufferView * bv)
+string const freefont2string()
 {
-	LyXFont font(LyXFont::ALL_IGNORE);
-	font.setNoun(LyXFont::TOGGLE);
-	ToggleAndShow(bv, font);
+	string data;
+	if (font2string(freefont, toggleall, data))
+		return data;
+	return string();
 }
 
 
-#ifndef NEW_INSETS
-void Margin(BufferView * bv)
+void update_and_apply_freefont(BufferView * bv, string const & data)
 {
-	if (bv->available()) {
-		bv->owner()->getMiniBuffer()->Set(_("Inserting margin note..."));
-		bv->hideCursor();
-		bv->update(BufferView::SELECT|BufferView::FITCUR);
-		bv->text->InsertFootnoteEnvironment(bv, LyXParagraph::MARGIN);
-		bv->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+	LyXFont font;
+	bool toggle;
+	if (string2font(data, font, toggle)) {
+		freefont = font;
+		toggleall = toggle;
+		apply_freefont(bv);
 	}
 }
-#endif
 
 
-void Lang(BufferView * bv, string const & l)
+void apply_freefont(BufferView * bv)
 {
-	LyXFont font(LyXFont::ALL_IGNORE);
-	Languages::iterator lit = languages.find(l);
-	if (lit != languages.end()) {
-		font.setLanguage(&(*lit).second);
-		ToggleAndShow(bv, font);
-	} else
-		WriteAlert(_("Error! unknown language"),l);
+	toggleAndShow(bv, freefont, toggleall);
+	bv->owner()->view_state_changed();
+	bv->buffer()->markDirty();
+	bv->owner()->message(_("Character set"));
 }
 
 
-#ifndef NEW_INSETS
-void Melt(BufferView * bv)
+void emph(BufferView * bv)
 {
-	if (!bv->available()) return;
-	
-	bv->owner()->getMiniBuffer()->Set(_("Melt"));
-	bv->hideCursor();
-	bv->beforeChange();
-	bv->update(BufferView::SELECT|BufferView::FITCUR);
-	bv->text->MeltFootnoteEnvironment(bv);
-	bv->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+	LyXFont font(LyXFont::ALL_IGNORE);
+	font.setEmph(LyXFont::TOGGLE);
+	toggleAndShow(bv, font);
 }
-#endif
 
 
-void Tex(BufferView * bv)
+void bold(BufferView * bv)
 {
 	LyXFont font(LyXFont::ALL_IGNORE);
-	font.setLatex (LyXFont::TOGGLE);
-	ToggleAndShow(bv, font);
+	font.setSeries(LyXFont::BOLD_SERIES);
+	toggleAndShow(bv, font);
 }
 
 
-// Change environment depth.
-// if decInc >= 0, increment depth
-// if decInc <  0, decrement depth
-void changeDepth(BufferView * bv, int decInc)
+void noun(BufferView * bv)
 {
-	if (!bv->available()) return;
-	
-	bv->hideCursor();
-	bv->update(BufferView::SELECT|BufferView::FITCUR);
-	if (decInc >= 0)
-		bv->text->IncDepth(bv);
-	else
-		bv->text->DecDepth(bv);
-	bv->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
-	bv->owner()->getMiniBuffer()
-		->Set(_("Changed environment depth"
-			" (in possible range, maybe not)"));
+	LyXFont font(LyXFont::ALL_IGNORE);
+	font.setNoun(LyXFont::TOGGLE);
+	toggleAndShow(bv, font);
 }
 
 
-void Free(BufferView * bv)
+void number(BufferView * bv)
 {
-	ToggleAndShow(bv, UserFreeFont(bv->buffer()->params));
+	LyXFont font(LyXFont::ALL_IGNORE);
+	font.setNumber(LyXFont::TOGGLE);
+	toggleAndShow(bv, font);
 }
 
-
-// How should this actually work? Should it prohibit input in all BufferViews,
-// or just in the current one? If "just the current one", then it should be
-// placed in BufferView. If "all BufferViews" then LyXGUI (I think) should
-// run "ProhibitInput" on all LyXViews which will run prohibitInput on all
-// BufferViews. Or is it perhaps just the (input in) BufferViews in the
-// current LyxView that should be prohibited (Lgb) (This applies to
-// "AllowInput" as well.)
-void ProhibitInput(BufferView * bv)
+void lang(BufferView * bv, string const & l)
 {
-	bv->hideCursor();
-
-	static Cursor cursor;
-	static bool cursor_undefined = true;
-   
-	if (cursor_undefined){
-		cursor = XCreateFontCursor(fl_display, XC_watch);
-		XFlush(fl_display);
-		cursor_undefined = false;
-	}
-   
-	/* set the cursor to the watch for all forms and the canvas */ 
-	XDefineCursor(fl_display, bv->owner()->getForm()->window, 
-		      cursor);
-	if (fd_form_paragraph->form_paragraph->visible)
-		XDefineCursor(fl_display,
-			      fd_form_paragraph->form_paragraph->window,
-			      cursor);
-	if (fd_form_character->form_character->visible)
-		XDefineCursor(fl_display,
-			      fd_form_character->form_character->window,
-			      cursor);
-
-	XFlush(fl_display);
-	fl_deactivate_all_forms();
+	LyXFont font(LyXFont::ALL_IGNORE);
+	Language const * lang = languages.getLanguage(l);
+	if (lang) {
+		font.setLanguage(lang);
+		toggleAndShow(bv, font);
+	} else
+		Alert::alert(_("Error! unknown language"),l);
 }
 
 
-void AllowInput(BufferView * bv)
+// Change environment depth.
+// if decInc >= 0, increment depth
+// if decInc <	0, decrement depth
+void changeDepth(BufferView * bv, LyXText * text, int decInc)
 {
-	/* reset the cursor from the watch for all forms and the canvas */
-   
-	XUndefineCursor(fl_display, bv->owner()->getForm()->window);
-	if (fd_form_paragraph->form_paragraph->visible)
-		XUndefineCursor(fl_display,
-				fd_form_paragraph->form_paragraph->window);
-	if (fd_form_character->form_character->visible)
-		XUndefineCursor(fl_display,
-				fd_form_character->form_character->window);
-
-	XFlush(fl_display);
-	fl_activate_all_forms();
+	if (!bv->available() || !text)
+	    return;
+
+	bv->hideCursor();
+	bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR);
+	if (decInc >= 0)
+		text->incDepth(bv);
+	else
+		text->decDepth(bv);
+	if (text->inset_owner)
+		bv->updateInset((Inset *)text->inset_owner, true);
+	bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 }
 
 
-void Code(BufferView * bv)
+void code(BufferView * bv)
 {
 	LyXFont font(LyXFont::ALL_IGNORE);
 	font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good
-	ToggleAndShow(bv, font);
+	toggleAndShow(bv, font);
 }
 
 
-void Sans(BufferView * bv)
+void sans(BufferView * bv)
 {
 	LyXFont font(LyXFont::ALL_IGNORE);
 	font.setFamily(LyXFont::SANS_FAMILY);
-	ToggleAndShow(bv, font);
+	toggleAndShow(bv, font);
 }
 
 
-void Roman(BufferView * bv)
+void roman(BufferView * bv)
 {
 	LyXFont font(LyXFont::ALL_IGNORE);
 	font.setFamily(LyXFont::ROMAN_FAMILY);
-	ToggleAndShow(bv, font);
+	toggleAndShow(bv, font);
 }
 
 
-void StyleReset(BufferView * bv)
+void styleReset(BufferView * bv)
 {
 	LyXFont font(LyXFont::ALL_INHERIT, ignore_language);
-	ToggleAndShow(bv, font);
+	toggleAndShow(bv, font);
 }
 
 
-void Underline(BufferView * bv)
+void underline(BufferView * bv)
 {
 	LyXFont font(LyXFont::ALL_IGNORE);
 	font.setUnderbar(LyXFont::TOGGLE);
-	ToggleAndShow(bv, font);
+	toggleAndShow(bv, font);
 }
 
 
-void FontSize(BufferView * bv, string const & size)
+void fontSize(BufferView * bv, string const & size)
 {
 	LyXFont font(LyXFont::ALL_IGNORE);
-	font.setGUISize(size);
-	ToggleAndShow(bv, font);
+	font.setLyXSize(size);
+	toggleAndShow(bv, font);
 }
 
 
-// Returns the current font and depth as a message. 
-string CurrentState(BufferView * bv)
+// Returns the current font and depth as a message.
+string const currentState(BufferView * bv)
 {
-	string state;
-	if (bv->available()) { 
-		// I think we should only show changes from the default
-		// font. (Asger)
-		LyXText *text = 0;
-
-		if (bv->the_locking_inset)
-		    text = bv->the_locking_inset->getLyXText(bv);
-		if (!text)
-		    text = bv->text;
-
-		Buffer * buffer = bv->buffer();
-		LyXFont font = text->real_current_font;
-		LyXFont const & defaultfont =
-			textclasslist
-			.TextClass(buffer->params.textclass)
-			.defaultfont();
-		font.reduce(defaultfont);
-		state = _("Font: ") + font.stateText(&buffer->params);
-		// The paragraph depth
-		int depth = text->GetDepth();
-		if (depth > 0) 
-			state += string(_(", Depth: ")) + tostr(depth);
-		// The paragraph spacing, but only if different from
-		// buffer spacing.
-		if (!text->cursor.par()->spacing.isDefault()) {
-			Spacing::Space cur_space =
-				text->cursor.par()->spacing.getSpace();
-			state += _(", Spacing: ");
-			switch (cur_space) {
-			case Spacing::Single:
-				state += _("Single");
-				break;
-			case Spacing::Onehalf:
-				state += _("Onehalf");
-				break;
-			case Spacing::Double:
-				state += _("Double");
-				break;
-			case Spacing::Other:
-				state += _("Other (");
-				state += tostr(text->cursor.par()->spacing.getValue());
-				state += ")";
-				break;
-			case Spacing::Default:
-				// should never happen, do nothing
-				break;
-			}
+	if (!bv->available())
+		return string();
+
+	ostringstream state;
+
+	LyXText * text = bv->getLyXText();
+	Buffer * buffer = bv->buffer();
+	LyXCursor const & c(text->cursor);
+
+	bool const show_change = buffer->params.tracking_changes
+		&& c.pos() != c.par()->size()
+		&& c.par()->lookupChange(c.pos()) != Change::UNCHANGED;
+
+	if (show_change) {
+		Change change(c.par()->lookupChangeFull(c.pos()));
+		Author const & a(bv->buffer()->authors().get(change.author));
+		state << _("Change: ") << a.name();
+		if (!a.email().empty()) {
+			state << " (" << a.email() << ")";
+		}
+		if (change.changetime)
+			state << _(" at ") << ctime(&change.changetime);
+		state << " : ";
+	}
+
+	// I think we should only show changes from the default
+	// font. (Asger)
+	LyXFont font = text->real_current_font;
+	LyXFont const & defaultfont =
+		buffer->params.getLyXTextClass().defaultfont();
+	font.reduce(defaultfont);
+
+#if USE_BOOST_FORMAT
+	state << boost::format(_("Font: %1$s")) % font.stateText(&buffer->params);
+#else
+	state << _("Font: ") << font.stateText(&buffer->params);
+#endif
+
+	// The paragraph depth
+	int depth = text->getDepth();
+	if (depth > 0) {
+#if USE_BOOST_FORMAT
+		state << boost::format(_(", Depth: %1$d")) % depth;
+#else
+		state << _(", Depth: ") << depth;
+#endif
+	}
+
+
+	// The paragraph spacing, but only if different from
+	// buffer spacing.
+	if (!text->cursor.par()->params().spacing().isDefault()) {
+		Spacing::Space cur_space =
+			text->cursor.par()->params().spacing().getSpace();
+		state << _(", Spacing: ");
+
+		switch (cur_space) {
+		case Spacing::Single:
+			state << _("Single");
+			break;
+		case Spacing::Onehalf:
+			state << _("OneHalf");
+			break;
+		case Spacing::Double:
+			state << _("Double");
+			break;
+		case Spacing::Other:
+			state << _("Other (")
+			      << text->cursor.par()->params().spacing().getValue()
+			      << ')';
+			break;
+		case Spacing::Default:
+			// should never happen, do nothing
+			break;
 		}
 	}
-	return state;
+#ifdef DEVEL_VERSION
+	state << _(", Paragraph: ") << text->cursor.par()->id();
+#endif
+	return STRCONV(state.str());
 }
 
 
-/* -------> Does the actual toggle job of the XxxCB() calls above.
+/* Does the actual toggle job of the calls above.
  * Also shows the current font state.
  */
-void ToggleAndShow(BufferView * bv, LyXFont const & font)
+void toggleAndShow(BufferView * bv, LyXFont const & font, bool toggleall)
 {
-	if (bv->available()) { 
-		bv->hideCursor();
-		bv->update(BufferView::SELECT|BufferView::FITCUR);
-		if (bv->the_locking_inset)
-			bv->the_locking_inset->SetFont(bv, font, toggleall);
-		else
-			bv->text->ToggleFree(bv, font, toggleall);
-		bv->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
-
-		if (font.language() != ignore_language ||
-		    font.latex() != LyXFont::IGNORE) {
-			LyXText * text = bv->text;
-			LyXCursor & cursor = text->cursor;
-			text->ComputeBidiTables(bv->buffer(), cursor.row());
-			if (cursor.boundary() != 
-			    text->IsBoundary(bv->buffer(), cursor.par(), cursor.pos(),
-					     text->real_current_font) )
-				text->SetCursor(bv, cursor.par(), cursor.pos(),
-						false, !cursor.boundary());
-		}
+	if (!bv->available())
+		return;
+
+	if (bv->theLockingInset()) {
+		bv->theLockingInset()->setFont(bv, font, toggleall);
+		return;
+	}
+
+	LyXText * text = bv->getLyXText();
+	// FIXME: can this happen ??
+	if (!text)
+		return;
+
+	bv->hideCursor();
+	bv->update(text, BufferView::SELECT | BufferView::FITCUR);
+	text->toggleFree(bv, font, toggleall);
+	bv->update(text, BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
+
+	if (font.language() != ignore_language ||
+	    font.number() != LyXFont::IGNORE) {
+		LyXCursor & cursor = text->cursor;
+		text->computeBidiTables(bv->buffer(), cursor.row());
+		if (cursor.boundary() !=
+		    text->isBoundary(bv->buffer(), cursor.par(), cursor.pos(),
+				     text->real_current_font))
+			text->setCursor(bv, cursor.par(), cursor.pos(),
+					false, !cursor.boundary());
 	}
 }