remove return arg from fullRebreak, fix last "Standards", new operaotr>> for lyxstring (might need more work), some ws changes

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@4108 a592a061-630c-0410-9148-cb99ea01b6c8

src/BufferView_pimpl.C

@@ -1092,20 +1092,19 @@ void BufferView::Pimpl::update()
 		screen_->update(bv_->text, bv_);
 		bool fitc = false;
 		while (bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
-			if (bv_->text->fullRebreak(bv_)) {
+			bv_->text->fullRebreak(bv_);
-				st = LyXText::NEED_MORE_REFRESH;
+			st = LyXText::NEED_MORE_REFRESH;
-				bv_->text->setCursor(bv_, bv_->text->cursor.par(),
+			bv_->text->setCursor(bv_, bv_->text->cursor.par(),
-									 bv_->text->cursor.pos());
+					     bv_->text->cursor.pos());
-				if (bv_->text->selection.set()) {
+			if (bv_->text->selection.set()) {
-					bv_->text->setCursor(bv_, bv_->text->selection.start,
+				bv_->text->setCursor(bv_, bv_->text->selection.start,
-								  bv_->text->selection.start.par(),
+						     bv_->text->selection.start.par(),
-								  bv_->text->selection.start.pos());
+						     bv_->text->selection.start.pos());
-					bv_->text->setCursor(bv_, bv_->text->selection.end,
+				bv_->text->setCursor(bv_, bv_->text->selection.end,
-								  bv_->text->selection.end.par(),
+						     bv_->text->selection.end.par(),
-								  bv_->text->selection.end.pos());
+						     bv_->text->selection.end.pos());
-				}
-				fitc = true;
 			}
+			fitc = true;
 			bv_->text->status(bv_, st);
 			screen_->update(bv_->text, bv_);
 		}
@@ -1655,6 +1654,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	lyxerr[Debug::ACTION] << "BufferView::Pimpl::Dispatch: action["
 			      << action <<"] arg[" << argument << "]" << endl;
 
+	LyXTextClass const & tclass = textclasslist[buffer_->params.textclass];
+
 	switch (action) {
 		// --- Misc -------------------------------------------
 	case LFUN_APPENDIX:
@@ -1675,7 +1676,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		InsetCommandParams p;
 		p.setCmdName("tableofcontents");
 		Inset * inset = new InsetTOC(p);
-		if (!insertInset(inset, "Standard"))
+		if (!insertInset(inset, tclass.defaultLayoutName()))
 			delete inset;
 		break;
 	}
@@ -1802,15 +1803,12 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 
 		// Derive layout number from given argument (string)
 		// and current buffer's textclass (number). */
-		textclass_type tclass = buffer_->params.textclass;
+		bool hasLayout = tclass.hasLayout(argument);
-		bool hasLayout =
-			textclasslist[tclass].hasLayout(argument);
 		string layout = argument;
 
 		// If the entry is obsolete, use the new one instead.
 		if (hasLayout) {
-			string const & obs = textclasslist[tclass][layout]
+			string const & obs = tclass[layout].obsoleted_by();
-				.obsoleted_by();
 			if (!obs.empty())
 				layout = obs;
 		}
@@ -2488,7 +2486,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	{
 		LyXText * lt = bv_->getLyXText();
 
-		LyXLayout const & style = textclasslist[buffer_->params.textclass][lt->cursor.par()->layout()];
+		LyXLayout const & style = tclass[lt->cursor.par()->layout()];
 
 		if (style.free_spacing) {
 			lt->insertChar(bv_, ' ');
@@ -3209,7 +3207,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	{
 		InsetCommandParams p("printindex");
 		Inset * inset = new InsetPrintIndex(p);
-		if (!insertInset(inset, "Standard"))
+		if (!insertInset(inset, tclass.defaultLayoutName()))
 			delete inset;
 	}
 	break;
@@ -3218,7 +3216,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	{
 		InsetCommandParams p("lyxparent", argument);
 		Inset * inset = new InsetParent(p, *buffer_);
-		if (!insertInset(inset, "Standard"))
+		if (!insertInset(inset, tclass.defaultLayoutName()))
 			delete inset;
 	}
 
@@ -3243,7 +3241,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	case LFUN_FLOAT_LIST:
 		if (floatList.typeExist(argument)) {
 			Inset * inset = new InsetFloatList(argument);
-			if (!insertInset(inset, "Standard"))
+			if (!insertInset(inset, tclass.defaultLayoutName()))
 				delete inset;
 		} else {
 			lyxerr << "Non-existent float type: "

src/ChangeLog

@@ -1,3 +1,19 @@
+2002-05-02  Lars Gullik Bjønnes  <larsbj@birdstep.com>
+
+	* screen.C (drawFromTo): change sine fullRebreak always return
+	true.
+
+	* buffer.C (parseSingleLyXformat2Token): reindent some
+
+	* BufferView_pimpl.C (update): change since fullRebreak always
+	return true.
+	(Dispatch): git rid of the last hardcoded "Standard"s.
+
+2002-05-01  Lars Gullik Bjønnes  <larsbj@birdstep.com>
+
+	* text2.[Ch] (fullRebreak): make it return void now that we always
+	returned true.
+
 2002-04-30  Juergen Vigna  <jug@sad.it>
 
 	* buffer.C (parseSingleLyXformat2Token): reset the font before the

src/WorkArea.C

@@ -401,6 +401,9 @@ int WorkArea::work_area_handler(FL_OBJECT * ob, int event,
 		LyXLookupString(ev, dummy, 1, &keysym);
 #else
 		XLookupString(xke, dummy, 1, &keysym, 0);
+//		int num_keys = XLookupString(xke, dummy, 10, &keysym, &xcs);
+//		lyxerr << "We have " << num_keys << " keys in the returned buffer" << endl;
+//		lyxerr << "Our dummy string is " << dummy << endl;
 #endif
 		if (lyxerr.debugging(Debug::KEY)) {
 			char const * tmp = XKeysymToString(key);

src/buffer.C

@@ -1240,19 +1240,86 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 	// minipage. Currently I am not investing any effort
 	// in fixing those cases.
 
-	//lyxerr << "Call depth: " << call_depth << endl;
+//	lyxerr << "Call depth: " << call_depth << endl;
-	if (checkminipage && (call_depth == 1)) {
+//	lyxerr << "Checkminipage: " << checkminipage << endl;
-	checkminipage = false;
-	if (minipar && (minipar != par) &&
-	    (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE))
-	{
-		lyxerr << "minipages in a row" << endl;
-		if (par->params().pextraStartMinipage()) {
-			lyxerr << "start new minipage" << endl;
-			// minipages in a row
-			par->previous()->next(0);
-			par->previous(0);
 
+	if (checkminipage && (call_depth == 1)) {
+		checkminipage = false;
+		if (minipar && (minipar != par) &&
+		    (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE)) {
+			lyxerr << "minipages in a row" << endl;
+			if (par->params().pextraStartMinipage()) {
+				lyxerr << "start new minipage" << endl;
+				// minipages in a row
+				par->previous()->next(0);
+				par->previous(0);
+
+				Paragraph * tmp = minipar;
+				while (tmp) {
+					tmp->params().pextraType(0);
+					tmp->params().pextraWidth(string());
+					tmp->params().pextraWidthp(string());
+					tmp->params().pextraAlignment(0);
+					tmp->params().pextraHfill(false);
+					tmp->params().pextraStartMinipage(false);
+					tmp = tmp->next();
+				}
+				// create a new paragraph to insert the
+				// minipages in the following case
+				if (par->params().pextraStartMinipage() &&
+				    !par->params().pextraHfill()) {
+					Paragraph * p = new Paragraph;
+					p->layout(textclasslist[params.textclass].defaultLayoutName());
+
+					p->previous(parBeforeMinipage);
+					parBeforeMinipage->next(p);
+					p->next(0);
+					p->params().depth(parBeforeMinipage->params().depth());
+					parBeforeMinipage = p;
+				}
+				InsetMinipage * mini = new InsetMinipage(params);
+				mini->pos(static_cast<InsetMinipage::Position>(par->params().pextraAlignment()));
+				mini->pageWidth(LyXLength(par->params().pextraWidth()));
+				if (!par->params().pextraWidthp().empty()) {
+					lyxerr << "WP:" << mini->pageWidth().asString() << endl;
+					mini->pageWidth(LyXLength((par->params().pextraWidthp())+"col%"));
+				}
+				Paragraph * op = mini->firstParagraph();
+				mini->inset.paragraph(par);
+				//
+				// and free the old ones!
+				//
+				while(op) {
+					Paragraph * pp = op->next();
+					delete op;
+					op = pp;
+				}
+				// Insert the minipage last in the
+				// previous paragraph.
+				if (par->params().pextraHfill()) {
+					parBeforeMinipage->insertChar
+						(parBeforeMinipage->size(),
+						 Paragraph::META_HFILL, font);
+				}
+				parBeforeMinipage->insertInset
+					(parBeforeMinipage->size(), mini, font);
+
+				minipar = par;
+			} else {
+				lyxerr << "new minipage par" << endl;
+				//nothing to do just continue reading
+			}
+
+		} else if (minipar && (minipar != par)) {
+			lyxerr << "last minipage par read" << endl;
+			// The last paragraph read was not part of a
+			// minipage but the par linked list is...
+			// So we need to remove the last par from the
+			// rest
+			if (par->previous())
+				par->previous()->next(0);
+			par->previous(parBeforeMinipage);
+			parBeforeMinipage->next(par);
 			Paragraph * tmp = minipar;
 			while (tmp) {
 				tmp->params().pextraType(0);
@@ -1263,28 +1330,44 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				tmp->params().pextraStartMinipage(false);
 				tmp = tmp->next();
 			}
-			// create a new paragraph to insert the
+			depth = parBeforeMinipage->params().depth();
-			// minipages in the following case
+			// and set this depth on the par as it has not been set already
-			if (par->params().pextraStartMinipage() &&
+			par->params().depth(depth);
-			    !par->params().pextraHfill()) {
+			minipar = parBeforeMinipage = 0;
-				Paragraph * p = new Paragraph;
+		} else if (!minipar &&
-				p->layout(textclasslist[params.textclass].defaultLayoutName());
+			   (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE)) {
+			// par is the first paragraph in a minipage
+			lyxerr << "begin minipage" << endl;
+			// To minimize problems for
+			// the users we will insert
+			// the first minipage in
+			// a sequence of minipages
+			// in its own paragraph.
+			Paragraph * p = new Paragraph;
+			p->layout(textclasslist[params.textclass].defaultLayoutName());
+			p->previous(par->previous());
+			p->next(0);
+			p->params().depth(depth);
+			par->params().depth(0);
+			depth = 0;
+			if (par->previous())
+				par->previous()->next(p);
+			par->previous(0);
+			parBeforeMinipage = p;
+			minipar = par;
+			if (!first_par || (first_par == par))
+				first_par = p;
 
-				p->previous(parBeforeMinipage);
-				parBeforeMinipage->next(p);
-				p->next(0);
-				p->params().depth(parBeforeMinipage->params().depth());
-				parBeforeMinipage = p;
-			}
 			InsetMinipage * mini = new InsetMinipage(params);
-			mini->pos(static_cast<InsetMinipage::Position>(par->params().pextraAlignment()));
+			mini->pos(static_cast<InsetMinipage::Position>(minipar->params().pextraAlignment()));
-			mini->pageWidth(LyXLength(par->params().pextraWidth()));
+			mini->pageWidth(LyXLength(minipar->params().pextraWidth()));
 			if (!par->params().pextraWidthp().empty()) {
-			    lyxerr << "WP:" << mini->pageWidth().asString() << endl;
+				lyxerr << "WP:" << mini->pageWidth().asString() << endl;
-			    mini->pageWidth(LyXLength((par->params().pextraWidthp())+"col%"));
+				mini->pageWidth(LyXLength((par->params().pextraWidthp())+"col%"));
 			}
+
 			Paragraph * op = mini->firstParagraph();
-			mini->inset.paragraph(par);
+			mini->inset.paragraph(minipar);
 			//
 			// and free the old ones!
 			//
@@ -1293,100 +1376,17 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				delete op;
 				op = pp;
 			}
+
 			// Insert the minipage last in the
 			// previous paragraph.
-			if (par->params().pextraHfill()) {
+			if (minipar->params().pextraHfill()) {
 				parBeforeMinipage->insertChar
 					(parBeforeMinipage->size(),
 					 Paragraph::META_HFILL, font);
 			}
 			parBeforeMinipage->insertInset
 				(parBeforeMinipage->size(), mini, font);
-
-			minipar = par;
-		} else {
-			lyxerr << "new minipage par" << endl;
-			//nothing to do just continue reading
 		}
-
-	} else if (minipar && (minipar != par)) {
-		lyxerr << "last minipage par read" << endl;
-		// The last paragraph read was not part of a
-		// minipage but the par linked list is...
-		// So we need to remove the last par from the
-		// rest
-		if (par->previous())
-			par->previous()->next(0);
-		par->previous(parBeforeMinipage);
-		parBeforeMinipage->next(par);
-		Paragraph * tmp = minipar;
-		while (tmp) {
-			tmp->params().pextraType(0);
-			tmp->params().pextraWidth(string());
-			tmp->params().pextraWidthp(string());
-			tmp->params().pextraAlignment(0);
-			tmp->params().pextraHfill(false);
-			tmp->params().pextraStartMinipage(false);
-			tmp = tmp->next();
-		}
-		depth = parBeforeMinipage->params().depth();
-		// and set this depth on the par as it has not been set already
-		par->params().depth(depth);
-		minipar = parBeforeMinipage = 0;
-	} else if (!minipar &&
-		   (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE))
-	{
-		// par is the first paragraph in a minipage
-		lyxerr << "begin minipage" << endl;
-		// To minimize problems for
-		// the users we will insert
-		// the first minipage in
-		// a sequence of minipages
-		// in its own paragraph.
-		Paragraph * p = new Paragraph;
-		p->layout(textclasslist[params.textclass].defaultLayoutName());
-		p->previous(par->previous());
-		p->next(0);
-		p->params().depth(depth);
-		par->params().depth(0);
-		depth = 0;
-		if (par->previous())
-			par->previous()->next(p);
-		par->previous(0);
-		parBeforeMinipage = p;
-		minipar = par;
-		if (!first_par || (first_par == par))
-			first_par = p;
-
-		InsetMinipage * mini = new InsetMinipage(params);
-		mini->pos(static_cast<InsetMinipage::Position>(minipar->params().pextraAlignment()));
-		mini->pageWidth(LyXLength(minipar->params().pextraWidth()));
-		if (!par->params().pextraWidthp().empty()) {
-		    lyxerr << "WP:" << mini->pageWidth().asString() << endl;
-		    mini->pageWidth(LyXLength((par->params().pextraWidthp())+"col%"));
-		}
-
-		Paragraph * op = mini->firstParagraph();
-		mini->inset.paragraph(minipar);
-		//
-		// and free the old ones!
-		//
-		while(op) {
-			Paragraph * pp = op->next();
-			delete op;
-			op = pp;
-		}
-
-		// Insert the minipage last in the
-		// previous paragraph.
-		if (minipar->params().pextraHfill()) {
-			parBeforeMinipage->insertChar
-				(parBeforeMinipage->size(),
-				 Paragraph::META_HFILL, font);
-		}
-		parBeforeMinipage->insertInset
-			(parBeforeMinipage->size(), mini, font);
-	}
 	}
 	// End of pextra_minipage compability
 	--call_depth;

src/frontends/xforms/ChangeLog

@@ -1,10 +1,10 @@
 2002-04-30  Rob Lahaye <lahaye@users.sourceforge.net>
 	* FormDocument.C: "USletter" -> "US letter" etc.
-	                  "Other" -> "Custom".
+			  "Other" -> "Custom".
 	* FormParagraph.C: "Other" -> "Custom"
 	* FormPreferences.C: "USletter" -> "US letter" etc.
 	* forms/form_document.fd: 'Papersize" -> "Paper size"
-	                          style consistency
+				  style consistency
 	* forms/form_preferences.fd: style consistency
 
 2002-04-30  Angus Leeming  <a.leeming@ic.ac.uk>

src/insets/insetindex.C

@@ -39,8 +39,9 @@ void InsetIndex::edit(BufferView * bv, bool)
 
 int InsetIndex::docbook(Buffer const *, ostream & os) const
 {
-  os << "<indexterm><primary>" << getContents() << "</primary></indexterm>";
+	os << "<indexterm><primary>" << getContents()
-  return 0;
+	   << "</primary></indexterm>";
+	return 0;
 }
 
 
@@ -54,6 +55,7 @@ InsetPrintIndex::InsetPrintIndex(InsetCommandParams const & p, bool)
 	: InsetCommand(p)
 {}
 
+
 string const InsetPrintIndex::getScreenLabel(Buffer const *) const
 {
 	return _("Index");

src/insets/insetindex.h

@@ -60,13 +60,15 @@ public:
 	///
 	void edit(BufferView *, bool = true) {}
 	///
-	EDITABLE editable() const{ return NOT_EDITABLE; }
+	EDITABLE editable() const { return NOT_EDITABLE; }
 	///
 	bool display() const { return true; }
 	///
 	Inset::Code lyxCode() const;
 	///
 	string const getScreenLabel(Buffer const *) const;
+	///
+	virtual bool needFullRow() const { return true; }
 };
 
 #endif

src/insets/insettext.C

@@ -463,20 +463,20 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
 		int yf = y_offset + first;
 		y = 0;
 		while ((row != 0) && (yf < ph)) {
-			lt->getVisibleRow(bv, y+y_offset+first, int(x), row,
+			lt->getVisibleRow(bv, y + y_offset + first, int(x),
-						y+lt->first_y, cleared);
+					  row, y + lt->first_y, cleared);
 			if (bv->text->status() == LyXText::CHANGED_IN_DRAW) {
 				lt->need_break_row = row;
-				if (lt->fullRebreak(bv)) {
+				lt->fullRebreak(bv);
-					lt->setCursor(bv, lt->cursor.par(),lt->cursor.pos());
+				lt->setCursor(bv, lt->cursor.par(),
-					if (lt->selection.set()) {
+					      lt->cursor.pos());
-						lt->setCursor(bv, lt->selection.start,
+				if (lt->selection.set()) {
-									  lt->selection.start.par(),
+					lt->setCursor(bv, lt->selection.start,
-									  lt->selection.start.pos());
+						      lt->selection.start.par(),
-						lt->setCursor(bv, lt->selection.end,
+						      lt->selection.start.pos());
-									  lt->selection.end.par(),
+					lt->setCursor(bv, lt->selection.end,
-									  lt->selection.end.pos());
+						      lt->selection.end.par(),
-					}
+						      lt->selection.end.pos());
 				}
 				break;
 			}

src/lyxtext.h

@@ -177,9 +177,8 @@ public:
 	///
 	void insertInset(BufferView *, Inset * inset);
 
-	/** Completes the insertion with a full rebreak.
+	/** Completes the insertion with a full rebreak. */
-	    Returns true if something was broken. */
+	void fullRebreak(BufferView *);
-	bool fullRebreak(BufferView *);
 
 	///
 	mutable Row * need_break_row;

src/screen.C

@@ -130,10 +130,10 @@ void LyXScreen::drawFromTo(LyXText * text, BufferView * bv,
 				    x_offset, row, y + text->first_y);
 		internal = internal && (st != LyXText::CHANGED_IN_DRAW);
 		while (internal && text->status() == LyXText::CHANGED_IN_DRAW) {
-			if (text->fullRebreak(bv)) {
+			text->fullRebreak(bv);
-				st = LyXText::NEED_MORE_REFRESH;
+			st = LyXText::NEED_MORE_REFRESH;
-				text->setCursor(bv, text->cursor.par(), text->cursor.pos());
+			text->setCursor(bv, text->cursor.par(),
-			}
+					text->cursor.pos());
 			text->status(bv, st);
 			text->getVisibleRow(bv, y + y_offset,
 					    x_offset, row, y + text->first_y);

src/support/ChangeLog

@@ -1,3 +1,7 @@
+2002-05-02  Lars Gullik Bjønnes  <larsbj@birdstep.com>
+
+	* lyxstring.C (operator>>): try a new version of the operator>>
+
 2002-04-14  Herbert Voss  <voss@perce.de>
 
 	* lstrings.[Ch]: move the getVectorFromString and the vice versa

src/support/filetools.C

@@ -1043,7 +1043,7 @@ string const getExtFromContents(string const & filename)
 			break;
 		}
 
-		std::getline(ifs, str);
+		getline(ifs, str);
 		lyxerr[Debug::GRAPHICS] << "Scanstring: " << str << endl;
 
 		string const stamp = str.substr(0,2);
@@ -1371,10 +1371,9 @@ string const readBB_from_PSFile(string const & file)
 	std::ifstream is(file_.c_str());
 	while (is) {
 		string s;
-		std::getline(is,s);
+		getline(is,s);
 		if (contains(s,"%%BoundingBox:") && !contains(s,"atend"))
 			return (frontStrip(s.substr(14)));
 	}
 	return string();
 }
-

src/support/lyxstring.C

@@ -1732,16 +1732,9 @@ void swap(lyxstring & str1, lyxstring & str2)
 
 #include <iostream>
 
+#if 0
 istream & operator>>(istream & is, lyxstring & s)
 {
-#if 0
-	// very bad solution
-	char * nome = new char[1024];
-	is >> nome;
-	lyxstring tmp(nome);
-	delete [] nome;
-	if (!tmp.empty()) s = tmp;
-#else
 	// better solution
 	int w = is.width(0);
 	s.clear();
@@ -1752,9 +1745,44 @@ istream & operator>>(istream & is, lyxstring & s)
 		if (--w == 1) break;
 	}
 	if (s.empty()) is.setstate(std::ios::failbit);
-#endif
 	return is;
 }
+#else
+istream & operator>>(istream & is, lyxstring & str)
+{
+	typedef istream            istream_type;
+	typedef int         int_type;
+	typedef std::streambuf streambuf_type;
+	typedef string     string_type;
+	typedef string::size_type         size_type;
+	size_type extracted = 0;
+
+//	istream_type::sentry cerb(is, false);
+//	if (cerb) {
+		str.erase();
+		std::streamsize w = is.width();
+		size_type n;
+		n = w > 0 ? static_cast<size_type>(w) : str.max_size();
+
+		int_type const eof = EOF;
+		streambuf_type * sb = is.rdbuf();
+		int_type c = sb->sgetc();
+
+		while (extracted < n
+		       && c != eof && !isspace(c)) {
+			str += c;
+			++extracted;
+			c = sb->snextc();
+		}
+		if (c == eof)
+			is.setstate(std::ios::eofbit);
+		is.width(0);
+//	}
+	if (!extracted)
+		is.setstate(std::ios::failbit);
+	return is;
+}
+#endif
 
 
 ostream & operator<<(ostream & o, lyxstring const & s)

src/text2.C

@@ -900,18 +900,17 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur,
 }
 
 
-bool LyXText::fullRebreak(BufferView * bview)
+void LyXText::fullRebreak(BufferView * bview)
 {
 	if (!firstrow) {
 		init(bview);
-		return true;
+		return;
 	}
 	if (need_break_row) {
 		breakAgain(bview, need_break_row);
 		need_break_row = 0;
-		return true;
+		return;
 	}
-	return true;
 }