sourcedoc/Doxyfile: sourcedoc/Doxyfile.in config.status
cd $(top_builddir) \
- && CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
+ && CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
lgbtags:
etags --totals=yes --recurse=yes -o TAGS $(top_srcdir)/*
LyXText::text_status st = bv_->text->status();
screen_->update(bv_->text, bv_);
bool fitc = false;
- while(bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
+ while (bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
if (bv_->text->fullRebreak(bv_)) {
st = LyXText::NEED_MORE_REFRESH;
bv_->text->setCursor(bv_, bv_->text->cursor.par(),
+2001-12-05 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * BufferView_pimpl:
+ * CutAndPaste.C:
+ * DepTable.C:
+ * buffer.C:
+ * chset.C:
+ * lastfiles.C:
+ * lyxlex.C:
+ * lyxlex_pimpl.C:
+ * lyxserver.C:
+ * screen.C:
+ * tabular-old.C:
+ * tabular.C:
+ * text.C:
+ * trans_mgr.C:
+ * vc-backend.C: change "while(" to "while ("
+
+ * lyxlength.[Ch]: add zero function to check if length is zero or
+ not
+ * lyxgluelength.C: use it
+
2001-12-05 Allan Rae <rae@lyx.org>
* lyxlength.C: Attempted a fix for the abs(int) header selection.
}
// this paragraph's are of noone's owner!
Paragraph * p = buf;
- while(p) {
+ while (p) {
p->setInsetOwner(0);
p = p->next();
}
}
// this paragraph's are of noone's owner!
tmppar = buf;
- while(tmppar) {
+ while (tmppar) {
tmppar->setInsetOwner(0);
tmppar = tmppar->next();
}
int n = 1;
Paragraph * tmppar = buf;
- while(tmppar->next()) {
+ while (tmppar->next()) {
++n;
tmppar = tmppar->next();
}
unsigned long two = 0;
unsigned long mtime = 0;
- while(ifs >> nome >> one >> two >> mtime) {
+ while (ifs >> nome >> one >> two >> mtime) {
if (lyxerr.debugging(Debug::DEPEND)) {
lyxerr << "Read dep: "
<< nome << " "
}
list < PAR_TAG > temp;
- while(!tag_state.empty() && tag_close ) {
+ while (!tag_state.empty() && tag_close ) {
PAR_TAG k = tag_state.top();
tag_state.pop();
os << "</" << tag_name(k) << ">";
// was a bit neat. Anyway it is wrong to use the lyxlex parse
// without the use of a keyword table.
LRegex reg("^([12][0-9][0-9])[ \t]+\"([^ ]+)\".*");
- while(getline(ifs, line)) {
+ while (getline(ifs, line)) {
if (reg.exact_match(line)) {
LRegex::SubMatches const & sub = reg.exec(line);
int const n = lyx::atoi(line.substr(sub[1].first,
+2001-12-05 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * FormCitation.C:
+ * GUIRunTime.C: change "while(" to "while ("
+
2001-09-27 Angus Leeming <a.leeming@ic.ac.uk>
* Dialogs.C: remove splash dialog code.
vector<string> r;
string tmp, keys( params.getContents() );
keys = frontStrip( split(keys, tmp, ',') );
- while( !tmp.empty() )
+ while ( !tmp.empty() )
{
r.clear();
r.push_back(tmp);
void GUIRunTime::processEvents()
{
- while(Gnome::Main::instance()->events_pending())
+ while (Gnome::Main::instance()->events_pending())
Gnome::Main::instance()->iteration(FALSE);
}
+2001-12-05 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * qttableview.C: change "while(" to "while ("
+
2001-12-05 Allan Rae <rae@lyx.org>
* QParagraph.C (apply):
/**********************************************************************
-** $Id: qttableview.C,v 1.1 2001/12/01 02:24:27 levon Exp $
+** $Id: qttableview.C,v 1.2 2001/12/05 08:04:18 larsbj Exp $
**
** Implementation of QtTableView class
**
int firstRow = findRow( updateR.y() );
int firstCol = findCol( updateR.x() );
- int xStart, yStart;
+ int xStart;
+ int yStart;
if ( !colXPos( firstCol, &xStart ) || !rowYPos( firstRow, &yStart ) ) {
paint.eraseRect( updateR ); // erase area outside cells but in view
return;
int row = firstRow;
int col;
int yPos = yStart;
- int xPos = maxX+1; // in case the while() is empty
+ int xPos = maxX + 1; // in case the while() is empty
int nextX;
int nextY;
QRect winR = viewRect();
int pos = tw;
int nextCol = nCols - 1;
int nextCellWidth = cellWidth( nextCol );
- while( nextCol > 0 && pos > goal + nextCellWidth ) {
+ while ( nextCol > 0 && pos > goal + nextCellWidth ) {
pos -= nextCellWidth;
nextCellWidth = cellWidth( --nextCol );
}
int pos = th;
int nextRow = nRows - 1;
int nextCellHeight = cellHeight( nextRow );
- while( nextRow > 0 && pos > goal + nextCellHeight ) {
+ while ( nextRow > 0 && pos > goal + nextCellHeight ) {
pos -= nextCellHeight;
nextCellHeight = cellHeight( --nextRow );
}
+2001-12-05 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * FormFiledialog.C:
+ * xforms_helpers.C: change "while(" to "while ("
+
2001-12-05 Allan Rae <rae@lyx.org>
* FormParagraph.C (apply): One other LyXText fix.
force_ok = false;
// event loop
- while(true) {
+ while (true) {
FL_OBJECT * pObject = fl_do_forms();
if (pObject == pFileDlgForm->Ready) {
void FormMinipage::update()
{
- LyXLength len(controller().params().width.c_str());
- fl_set_input(dialog_->input_width,tostr(len.value()).c_str());
- fl_set_choice(dialog_->choice_width_units, len.unit()+1);
+ LyXLength len(controller().params().width);
+ fl_set_input(dialog_->input_width, tostr(len.value()).c_str());
+ fl_set_choice(dialog_->choice_width_units, len.unit() + 1);
switch (controller().params().pos) {
case InsetMinipage::top:
{
// Find '|' in the sc and return the string after that.
register char const * sd = sc;
- while(sd[0]!= 0 && sd[0] != '|') ++sd;
+ while (sd[0]!= 0 && sd[0] != '|') ++sd;
if (sd[0] == '|') {
++sd;
char const * flyx_ident_extract(char const * sc)
{
register char const * se = sc;
- while(se[0]!= 0 && se[0] != '|') ++se;
+ while (se[0]!= 0 && se[0] != '|') ++se;
if (se[0] == 0) return sc;
+2001-12-05 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * insetbib.C:
+ * insettabular.C:
+ * insettext.C: change "while(" to "while ("
+
2001-12-04 Juergen Vigna <jug@sad.it>
* insetert.C (edit): handle Inlined status.
// If we generate in a temp dir, we might need to give an
// absolute path there. This is a bit complicated since we can
// have a comma-separated list of bibliographies
- while(!adb.empty()) {
+ while (!adb.empty()) {
if (!buffer->niceFile &&
IsFileReadable(MakeAbsPath(adb, buffer->filepath)+".bib"))
adb = os::external_path(MakeAbsPath(adb, buffer->filepath));
string tmp;
string bibfiles = getContents();
bibfiles = split(bibfiles, tmp, ',');
- while(!tmp.empty()) {
+ while (!tmp.empty()) {
string file = findtexfile(ChangeExtension(tmp, "bib"), "bib");
lyxerr[Debug::LATEX] << "Bibfile: " << file << endl;
string::size_type len = clip.length();
string::size_type p = 0;
- while(p < len &&
+ while (p < len &&
((p = clip.find_first_of("\t\n", p)) != string::npos)) {
switch(clip[p]) {
case '\t':
int cell = 0;
int cells = paste_tabular->GetNumberOfCells();
p = cols = 0;
- while((cell < cells) && (p < len) &&
+ while ((cell < cells) && (p < len) &&
(p = clip.find_first_of("\t\n", p)) != string::npos) {
if (p >= len)
break;
break;
case '\n':
paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op));
- while(cols++ < maxCols)
+ while (cols++ < maxCols)
++cell;
cols = 0;
break;
int ly = tabular->GetDescentOfRow(actrow);
// first search the right row
- while((ly < y) && ((actrow+1) < tabular->rows())) {
+ while ((ly < y) && ((actrow+1) < tabular->rows())) {
cursor_.y(cursor_.y() + tabular->GetDescentOfRow(actrow) +
tabular->GetAscentOfRow(actrow + 1) +
tabular->GetAdditionalHeight(actrow + 1));
paste_tabular = new LyXTabular(this, *tabular); // rows, columns);
for (int i = 0; i < sel_row_start; ++i)
paste_tabular->DeleteRow(0);
- while(paste_tabular->rows() > rows)
+ while (paste_tabular->rows() > rows)
paste_tabular->DeleteRow(rows);
paste_tabular->SetTopLine(0, true, true);
paste_tabular->SetBottomLine(paste_tabular->GetFirstCellInRow(rows-1),
{
// check if my paragraphs are still valid
Paragraph * p = par;
- while(p) {
+ while (p) {
if (p == t->cursor.par())
break;
p = p->next();
id_ = ins->id_;
} else {
Paragraph * p = par;
- while(p) {
+ while (p) {
p->setInsetOwner(this);
p = p->next();
}
if (!return_par)
return_par = par;
par = return_par;
- while(return_par) {
+ while (return_par) {
return_par->setInsetOwner(this);
return_par = return_par->next();
}
lt->setCursor(bv, par, 0);
else {
Paragraph * p = par;
- while(p->next())
+ while (p->next())
p = p->next();
// int const pos = (p->size() ? p->size()-1 : p->size());
lt->setCursor(bv, p, p->size());
Paragraph * lp = par;
- while(lp) {
+ while (lp) {
for (Paragraph::inset_iterator it = lp->inset_iterator_begin(),
en = lp->inset_iterator_end();
it != en; ++it)
string tmp;
FileInfo fileInfo;
- while(getline(ifs, tmp) && files.size() < num_files) {
+ while (getline(ifs, tmp) && files.size() < num_files) {
if (dostat) {
if (!(fileInfo.newFile(tmp).exist() &&
fileInfo.isRegular()))
#endif
#include "lyxgluelength.h"
+#include "lengthcommon.h"
#include "Lsstream.h"
+#if 0
namespace {
// this is now here and in lyxlenght.h
"%", "c%", "p%", "l%" };
}
-
+#endif
LyXGlueLength::LyXGlueLength(LyXLength const & len)
: len_(len)
{
ostringstream buffer;
- if (plus_.value() != 0.0)
- if (minus_.value() != 0.0)
+ if (!plus_.zero())
+ if (!minus_.zero())
if (len_.unit() == plus_.unit() && len_.unit() == minus_.unit())
if (plus_.value() == minus_.value())
buffer << len_.value() << "+-"
<< unit_name[plus_.unit()];
else
- if (minus_.value() != 0.0)
+ if (!minus_.zero())
if (len_.unit() == minus_.unit())
buffer << len_.value() << '-' << minus_.value()
<< unit_name[len_.unit()];
{
ostringstream buffer;
- if (plus_.value() != 0.0)
- if (minus_.value() != 0.0)
+ if (!plus_.zero())
+ if (!minus_.zero())
buffer << len_.value() << unit_name[len_.unit()]
<< " plus "
<< plus_.value() << unit_name[plus_.unit()]
<< " plus "
<< plus_.value() << unit_name[plus_.unit()];
else
- if (minus_.value() != 0.0)
+ if (!minus_.zero())
buffer << len_.value() << unit_name[len_.unit()]
<< " minus "
<< minus_.value() << unit_name[minus_.unit()];
#endif
#include "lyxlength.h"
+#include "lengthcommon.h"
#include "Lsstream.h"
-#if defined(__GNUG__) && __GNUC__ == 2 && __GNUC_MINOR__ >= 95
#include <cstdlib>
-#else
-#include <cmath>
-#endif
+#if 0
namespace {
// this is now here and in lyxgluelength.C
}
}
+#endif
LyXLength::LyXLength()
}
+bool LyXLength::zero() const
+{
+ return val_ == 0.0;
+}
+
+
bool operator==(LyXLength const & l1, LyXLength const & l2)
{
return l1.value() == l2.value() && l1.unit() == l2.unit();
/// "data" must be a decimal number, followed by a unit
explicit LyXLength(string const & data);
-
+
///
double value() const;
///
void value(double);
///
void unit(LyXLength::UNIT unit);
-
- /// real length in SP
- //void lenght();
-
+ ///
+ bool zero() const;
/// conversion
string const asString() const;
///
string tmpstr = getString();
if (firstline) {
unsigned int i = 0;
- while(i < tmpstr.length()
+ while (i < tmpstr.length()
&& tmpstr[i] == ' ') {
++i;
prefix += ' ';
int i = 0;
unsigned char c = '\0';
char cc = 0;
- while(is && c != '\n' && i != (LEX_MAX_BUFF - 1)) {
+ while (is && c != '\n' && i != (LEX_MAX_BUFF - 1)) {
is.get(cc);
c = cc;
//lyxerr[Debug::LYXLEX] << "LyXLex::EatLine read char: `"
errno = 0;
int status;
// the single = is intended here.
- while((status = read(fd, charbuf, CMDBUFLEN-1)))
+ while ((status = read(fd, charbuf, CMDBUFLEN-1)))
{// break and return in loop
if (status > 0) // got something
{
charbuf[status]= '\0'; // turn it into a c string
lsbuf += strip(charbuf, '\r');
// commit any commands read
- while(lsbuf.find('\n') != string::npos) // while still
+ while (lsbuf.find('\n') != string::npos) // while still
// commands
// left
{
// Format: LYXCMD:<client>:<func>:<argstring>\n
//
bool server_only = false;
- while(*p) {
+ while (*p) {
// --- 1. check 'header' ---
if (compare(p, "LYXSRV:", 7) == 0) {
// --- 2. for the moment ignore the client name ---
string client;
- while(*p && *p != ':')
+ while (*p && *p != ':')
client += char(*p++);
if (*p == ':') ++p;
if (!*p) return;
// --- 3. get function name ---
string cmd;
- while(*p && *p != ':')
+ while (*p && *p != ':')
cmd += char(*p++);
// --- 4. parse the argument ---
string arg;
if (!server_only && *p == ':' && *(++p)) {
- while(*p && *p != '\n')
+ while (*p && *p != '\n')
arg += char(*p++);
if (*p) ++p;
}
+2001-12-05 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * math_arrayinset.C:
+ * math_boxinset.C:
+ * math_decorationinset.C:
+ * math_deliminset.C:
+ * math_dotsinset.C:
+ * math_exfuncinset.C:
+ * math_exintinset.C:
+ * math_funcinset.C:
+ * math_funcliminset.C:
+ * math_hullinset.C:
+ * math_kerninset.C:
+ * math_limopinset.C:
+ * math_sizeinset.C:
+ * math_stringinset.C:
+ * math_symbolinset.C:
+ * math_unknowninset.C: include math_streamstr.h and remove
+ unneeded c_str()
+
+ * math_symbolinset.[Ch]: add constructor taking string
+
+ * math_mathmlstream.C: move includes around
+
+ * math_streamstr.[Ch]: add operator<<(Stream, string) for
+ NormalStream, MapleStream, MathMLStream and OctaveStream
+
+ * math_gridinset.C: user LyXLength::zero
+
2001-11-19 Angus Leeming <a.leeming@ic.ac.uk>
* formula.C:
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
-#include <iterator>
-
#include "math_arrayinset.h"
#include "math_parser.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "Lsstream.h"
+#include <iterator>
+
using std::vector;
using std::istringstream;
using std::getline;
if (v_align_ == 't' || v_align_ == 'b')
os << '[' << char(v_align_) << ']';
- os << '{' << halign().c_str() << "}\n";
+ os << '{' << halign() << "}\n";
MathGridInset::write(os);
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
#include "math_cursor.h"
#include "insets/insettext.h"
#include "math_mathmlstream.h"
-
+#include "math_streamstr.h"
MathBoxInset::MathBoxInset(string const & name)
: MathDimInset(), name_(name), text_(new InsetText), buffer_(0)
void MathBoxInset::write(WriteStream & os) const
{
- os << "\\" << name_.c_str() << "{" << cell(0) << "}";
+ os << "\\" << name_ << "{" << cell(0) << "}";
}
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
#include "math_support.h"
#include "math_parser.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
MathDecorationInset::MathDecorationInset(string const & name)
{
if (os.fragile() && protect())
os << "\\protect";
- os << '\\' << name_.c_str() << '{' << cell(0) << '}';
+ os << '\\' << name_ << '{' << cell(0) << '}';
}
void MathDecorationInset::normalize(NormalStream & os) const
{
- os << "[deco " << name_.c_str() << ' ' << cell(0) << ']';
+ os << "[deco " << name_ << ' ' << cell(0) << ']';
}
#include "math_parser.h"
#include "math_support.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "math_extern.h"
void MathDelimInset::write(WriteStream & os) const
{
- os << "\\left" << latexName(left_).c_str() << cell(0)
- << "\\right" << latexName(right_).c_str();
+ os << "\\left" << latexName(left_) << cell(0)
+ << "\\right" << latexName(right_);
}
void MathDelimInset::normalize(NormalStream & os) const
{
- os << "[delim " << latexName(left_).c_str() << ' '
- << latexName(right_).c_str() << ' ' << cell(0) << ']';
+ os << "[delim " << latexName(left_) << ' '
+ << latexName(right_) << ' ' << cell(0) << ']';
}
os << "abs(" << cell(0) << ")";
}
else
- os << left_.c_str() << cell(0) << right_.c_str();
+ os << left_ << cell(0) << right_;
}
void MathDelimInset::mathmlize(MathMLStream & os) const
{
- os << "<fenced open=\"" << left_.c_str() << "\" close=\""
- << right_.c_str() << "\">" << cell(0) << "</fenced>";
+ os << "<fenced open=\"" << left_ << "\" close=\""
+ << right_ << "\">" << cell(0) << "</fenced>";
}
if (isAbs())
os << "det(" << cell(0) << ")";
else
- os << left_.c_str() << cell(0) << right_.c_str();
+ os << left_ << cell(0) << right_;
}
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
#include "math_dotsinset.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "math_support.h"
void MathDotsInset::write(WriteStream & os) const
{
- os << '\\' << name_.c_str() << ' ';
+ os << '\\' << name_ << ' ';
}
void MathDotsInset::normalize(NormalStream & os) const
{
- os << "[" << name_.c_str() << "] ";
+ os << "[" << name_ << "] ";
}
+#include <config.h>
+
#include "math_exfuncinset.h"
#include "math_support.h"
#include "math_mathmlstream.h"
-
+#include "math_streamstr.h"
using std::ostream;
void MathExFuncInset::normalize(NormalStream & os) const
{
- os << '[' << name_.c_str() << ' ' << cell(0) << ']';
+ os << '[' << name_ << ' ' << cell(0) << ']';
}
void MathExFuncInset::maplize(MapleStream & os) const
{
- os << name_.c_str() << '(' << cell(0) << ')';
+ os << name_ << '(' << cell(0) << ')';
}
void MathExFuncInset::octavize(OctaveStream & os) const
{
- os << name_.c_str() << '(' << cell(0) << ')';
+ os << name_ << '(' << cell(0) << ')';
}
void MathExFuncInset::write(WriteStream & os) const
{
- os << '\\' << name_.c_str() << '{' << cell(0) << '}';
+ os << '\\' << name_ << '{' << cell(0) << '}';
}
+#include <config.h>
+
#include "math_exintinset.h"
#include "math_support.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "math_symbolinset.h"
#include "debug.h"
+using std::endl;
+
MathExIntInset::MathExIntInset(string const & name)
: MathNestInset(4), symbol_(name)
void MathExIntInset::normalize(NormalStream & os) const
{
- os << '[' << symbol_.c_str() << ' ' << cell(0) << ' ' << cell(1) << ' '
+ os << '[' << symbol_ << ' ' << cell(0) << ' ' << cell(1) << ' '
<< cell(2) << ' ' << cell(3) << ']';
}
void MathExIntInset::metrics(MathMetricsInfo const &) const
{
- lyxerr << "should not happen\n";
+ lyxerr << "should not happen" << endl;
}
void MathExIntInset::draw(Painter &, int, int) const
{
- lyxerr << "should not happen\n";
+ lyxerr << "should not happen" << endl;
}
void MathExIntInset::maplize(MapleStream & os) const
{
- os << symbol_.c_str() << '(';
+ os << symbol_ << '(';
if (cell(0).size())
os << cell(0);
else
void MathExIntInset::mathmlize(MathMLStream & os) const
{
- MathSymbolInset * sym = new MathSymbolInset(symbol_.c_str());
+ MathSymbolInset * sym = new MathSymbolInset(symbol_);
//if (hasScripts())
// mathmlize(sym, os);
//else
void MathExIntInset::write(WriteStream &) const
{
- lyxerr << "should not happen\n";
+ lyxerr << "should not happen" << endl;
}
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
#include "Painter.h"
#include "math_support.h"
#include "math_mathmlstream.h"
-
+#include "math_streamstr.h"
extern LyXFont WhichFont(short type, int size);
void MathFuncInset::maplize(MapleStream & os) const
{
- os << ' ' << name_.c_str();
+ os << ' ' << name_;
}
void MathFuncInset::mathmlize(MathMLStream & os) const
{
- os << MTag("mi") << name_.c_str() << ETag("mi");
+ os << MTag("mi") << name_ << ETag("mi");
}
void MathFuncInset::octavize(OctaveStream & os) const
{
- os << ' ' << name_.c_str();
+ os << ' ' << name_;
}
void MathFuncInset::normalize(NormalStream & os) const
{
- os << "[func " << name_.c_str() << ']';
+ os << "[func " << name_ << ']';
}
void MathFuncInset::write(WriteStream & os) const
{
- os << "\\" << name_.c_str() << ' ';
+ os << "\\" << name_ << ' ';
}
+#include <config.h>
+
#include "math_funcliminset.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "math_support.h"
void MathFuncLimInset::write(WriteStream & os) const
{
- os << '\\' << name_.c_str() << ' ';
+ os << '\\' << name_ << ' ';
}
void MathFuncLimInset::normalize(NormalStream & os) const
{
- os << "[funclim " << name_.c_str() << ']';
+ os << "[funclim " << name_ << ']';
}
{
string eol;
- if (rowinfo_[row].crskip_.value() != 0)
+ if (!rowinfo_[row].crskip_.zero())
eol += "[" + rowinfo_[row].crskip_.asLatexString() + "]";
// make sure an upcoming '[' does not break anything
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
-#include <vector>
-
#include "math_hullinset.h"
#include "math_support.h"
#include "debug.h"
#include "Painter.h"
#include "LaTeXFeatures.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
+
+#include <vector>
+using std::endl;
namespace {
default:
lyxerr << "mutation from '" << getType()
- << "' to '" << newtype << "' not implemented\n";
+ << "' to '" << newtype << "' not implemented"
+ << endl;
break;
}
break;
break;
default:
lyxerr << "mutation from '" << getType()
- << "' to '" << newtype << "' not implemented\n";
+ << "' to '" << newtype << "' not implemented"
+ << endl;
break;
}
break;
default:
lyxerr << "mutation from '" << getType()
- << "' to '" << newtype << "' not implemented\n";
+ << "' to '" << newtype << "' not implemented"
+ << endl;
break;
}
default:
lyxerr << "mutation from '" << getType()
- << "' to '" << newtype << "' not implemented\n";
+ << "' to '" << newtype << "' not implemented"
+ << endl;
+ break;
}
}
void MathHullInset::write(WriteStream & os) const
{
- header_write(os);
-
+ header_write(os);
+
bool n = numberedType();
-
+
for (row_type row = 0; row < nrows(); ++row) {
for (col_type col = 0; col < ncols(); ++col)
- os << cell(index(row, col)) << eocString(col).c_str();
+ os << cell(index(row, col)) << eocString(col);
if (n) {
if (!label_[row].empty())
- os << "\\label{" << label_[row].c_str() << "}";
+ os << "\\label{" << label_[row] << "}";
if (nonum_[row])
os << "\\nonumber ";
}
- os << eolString(row).c_str();
+ os << eolString(row);
}
-
- footer_write(os);
+
+ footer_write(os);
}
void MathHullInset::normalize(NormalStream & os) const
{
- os << "[formula " << normalName(getType()).c_str() << " ";
+ os << "[formula " << normalName(getType()) << " ";
MathGridInset::normalize(os);
os << "] ";
}
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
#include "math_kerninset.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "math_support.h"
void MathKernInset::write(WriteStream & os) const
{
- os << "\\kern" << wid_.asLatexString().c_str() << " ";
+ os << "\\kern" << wid_.asLatexString() << " ";
}
void MathKernInset::normalize(NormalStream & os) const
{
- os << "[kern " << wid_.asLatexString().c_str() << "]";
+ os << "[kern " << wid_.asLatexString() << "]";
}
void MathLimitOpInset::maplize(MapleStream &) const
{
- //os << name_.c_str() << '(' << cell(0) << ')';
+ //os << name_ << '(' << cell(0) << ')';
}
void MathLimitOpInset::mathmlize(MathMLStream &) const
{
- //os << name_.c_str() << '(' << cell(0) << ')';
+ //os << name_ << '(' << cell(0) << ')';
}
#include <config.h>
-#include <algorithm>
#include "math_mathmlstream.h"
#include "math_inset.h"
#include "math_extern.h"
#include "debug.h"
+#include <algorithm>
+
MathMLStream::MathMLStream(std::ostream & os)
: os_(os), tab_(0), line_(0), lastchar_(0)
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
#include "math_sizeinset.h"
#include "math_parser.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
MathSizeInset::MathSizeInset(latexkeys const * l)
void MathSizeInset::write(WriteStream & os) const
{
- os << "{\\" << key_->name.c_str() << ' ' << cell(0) << '}';
+ os << "{\\" << key_->name << ' ' << cell(0) << '}';
}
void MathSizeInset::normalize(NormalStream & os) const
{
- os << "[" << key_->name.c_str() << ' ' << cell(0) << ']';
+ os << "[" << key_->name << ' ' << cell(0) << ']';
}
#include <config.h>
-#include <algorithm>
-#include "math_mathmlstream.h"
#include "math_streamstr.h"
+#include "math_mathmlstream.h"
+
+#include <algorithm>
WriteStream & operator<<(WriteStream & ws, string const & s)
ws.line() += std::count(s.begin(), s.end(), '\n');
return ws;
}
+
+
+NormalStream & operator<<(NormalStream & ns, string const & s)
+{
+ ns.os() << s;
+ return ns;
+}
+
+
+MapleStream & operator<<(MapleStream & ms, string const & s)
+{
+ ms.os() << s;
+ return ms;
+}
+
+
+MathMLStream & operator<<(MathMLStream & ms, string const & s)
+{
+ ms.os() << s;
+ return ms;
+}
+
+
+OctaveStream & operator<<(OctaveStream & os, string const & s)
+{
+ os.os() << s;
+ return os;
+}
+// -*- C++ -*-
#ifndef MATH_STREAMSTR_H
#define MATH_STREAMSTR_H
#include "LString.h"
class WriteStream;
+class NormalStream;
+class MapleStream;
+class MathMLStream;
+class OctaveStream;
//
// writing strings directly
//
WriteStream & operator<<(WriteStream & ws, string const & s);
-
+NormalStream & operator<<(NormalStream & ns, string const & s);
+MapleStream & operator<<(MapleStream & ms, string const & s);
+MathMLStream & operator<<(MathMLStream & ms, string const & s);
+OctaveStream & operator<<(OctaveStream & os, string const & s);
#endif
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
-#include <cctype>
-
#include "math_stringinset.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "LColor.h"
#include "Painter.h"
#include "math_support.h"
#include "math_parser.h"
#include "debug.h"
+#include <cctype>
+
MathStringInset::MathStringInset()
: str_(), code_(LM_TC_MIN)
void MathStringInset::normalize(NormalStream & os) const
{
- os << "[string " << str_.c_str() << ' ' << "mathalpha" << "]";
+ os << "[string " << str_ << ' ' << "mathalpha" << "]";
}
void MathStringInset::maplize(MapleStream & os) const
{
if (code_ != LM_TC_VAR || str_.size() <= 1) {
- os << ' ' << str_.c_str() << ' ';
+ os << ' ' << str_ << ' ';
return;
}
void MathStringInset::octavize(OctaveStream & os) const
{
if (code_ != LM_TC_VAR || str_.size() <= 1) {
- os << ' ' << str_.c_str() << ' ';
+ os << ' ' << str_ << ' ';
return;
}
void MathStringInset::mathmlize(MathMLStream & os) const
{
if (code_ == LM_TC_VAR)
- os << "<mi> " << str_.c_str() << " </mi>";
+ os << "<mi> " << str_ << " </mi>";
else if (code_ == LM_TC_CONST)
- os << "<mn> " << str_.c_str() << " </mn>";
+ os << "<mn> " << str_ << " </mn>";
else if (code_ == LM_TC_RM || code_ == LM_TC_TEXTRM)
- os << "<mtext> " << str_.c_str() << " </mtext>";
+ os << "<mtext> " << str_ << " </mtext>";
else
- os << str_.c_str();
+ os << str_;
}
void MathStringInset::write(WriteStream & os) const
{
if (math_font_name(code_))
- os << '\\' << math_font_name(code_) << '{' << str_.c_str() << '}';
+ os << '\\' << math_font_name(code_) << '{' << str_ << '}';
else
- os << str_.c_str();
+ os << str_;
}
+#include <config.h>
+
#include "math_symbolinset.h"
#include "math_mathmlstream.h"
+#include "math_streamstr.h"
#include "math_support.h"
#include "math_parser.h"
#include "debug.h"
{}
+MathSymbolInset::MathSymbolInset(string const & name)
+ : sym_(in_word_set(name.c_str())), h_(0)
+{}
+
+
MathInset * MathSymbolInset::clone() const
{
void MathSymbolInset::normalize(NormalStream & os) const
{
- os << "[symbol " << name().c_str() << "]";
+ os << "[symbol " << name() << "]";
}
if (name() == "cdot")
os << '*';
else
- os << name().c_str();
+ os << name();
}
char const * type = MathMLtype(sym_->type);
os << '<' << type << "> ";
if (sym_->xmlname == "x") // unknown so far
- os << name().c_str();
+ os << name();
else
- os << sym_->xmlname.c_str();
+ os << sym_->xmlname;
os << " </" << type << '>';
}
if (name() == "cdot")
os << '*';
else
- os << name().c_str();
+ os << name();
}
void MathSymbolInset::write(WriteStream & os) const
{
- os << '\\' << name().c_str() << ' ';
+ os << '\\' << name() << ' ';
}
///
explicit MathSymbolInset(char const *);
///
+ explicit MathSymbolInset(string const &);
+ ///
MathInset * clone() const;
///
void metrics(MathMetricsInfo const & st) const;
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
#include "Painter.h"
#include "math_support.h"
#include "math_mathmlstream.h"
-
+#include "math_streamstr.h"
extern LyXFont WhichFont(short type, int size);
void MathUnknownInset::write(WriteStream & os) const
{
- os << "\\" << name_.c_str() << ' ';
+ os << "\\" << name_ << ' ';
}
void MathUnknownInset::normalize(NormalStream & os) const
{
- os << "[func " << name_.c_str() << ']';
+ os << "[func " << name_ << ']';
}
void MathUnknownInset::maplize(MapleStream & os) const
{
- os << name_.c_str();
+ os << name_;
}
void MathUnknownInset::mathmlize(MathMLStream & os) const
{
- os << MTag("mi") << name_.c_str() << ETag("mi");
+ os << MTag("mi") << name_ << ETag("mi");
}
void MathUnknownInset::octavize(OctaveStream & os) const
{
- os << name_.c_str();
+ os << name_;
}
text->getVisibleRow(bv, y + y_offset,
x_offset, row, y + text->first);
internal = internal && (st != LyXText::CHANGED_IN_DRAW);
- while(internal && text->status() == LyXText::CHANGED_IN_DRAW) {
+ while (internal && text->status() == LyXText::CHANGED_IN_DRAW) {
if (text->fullRebreak(bv)) {
st = LyXText::NEED_MORE_REFRESH;
text->setCursor(bv, text->cursor.par(), text->cursor.pos());
+2001-12-05 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * filetools.C:
+ * lstrings.C:
+ * lyxstring.C: change "while(" to "while ("
+
2001-12-03 Ben Stanley <bds02@uow.edu.au>
* lyxsum.C: Added mmap version of CRC and made it selected
if (real_file.empty()) {
do {
tmppath = split(tmppath, path_element, ';');
- } while(!tmppath.empty() && path_element.empty());
+ } while (!tmppath.empty() && path_element.empty());
} else {
notfound = false;
}
TempBase = AddPath(lyx::getcwd(), BasePath);
// Handle /./ at the end of the path
- while(suffixIs(TempBase, "/./"))
+ while (suffixIs(TempBase, "/./"))
TempBase.erase(TempBase.length() - 2);
// processes relative path
string lstr(a);
string::size_type i = 0;
string::size_type olen = strlen(oldstr);
- while((i = lstr.find(oldstr, i)) != string::npos) {
+ while ((i = lstr.find(oldstr, i)) != string::npos) {
lstr.replace(i, olen, newstr);
i += newstr.length(); // We need to be sure that we dont
// use the same i over and over again.
string lstr(a);
string::size_type i = 0;
string::size_type const olen = oldstr.length();
- while((i = lstr.find(oldstr, i)) != string::npos) {
+ while ((i = lstr.find(oldstr, i)) != string::npos) {
lstr.replace(i, olen, newstr);
i += newstr.length(); // We need to be sure that we dont
// use the same i over and over again.
}
if (equal) return t;
}
- } while(t-- > 0);
+ } while (t-- > 0);
return npos;
}
// very bad solution
char tmp = 0;
s.erase();
- while(is) {
+ while (is) {
is.get(tmp);
if (tmp != delim) {
s += tmp;
ret += ch;
ch = ' ';
}
- while((pos < str.length() - 1) && (str[++pos] != ch))
+ while ((pos < str.length() - 1) && (str[++pos] != ch))
ret += str[pos];
return true;
ret += ch;
}
++pos;
- while((pos < str.length() - 1) && isdigit(str[pos]))
+ while ((pos < str.length() - 1) && isdigit(str[pos]))
ret += str[pos++];
num = strToInt(ret);
ret += ch;
}
++pos;
- while((pos < str.length() - 1) && isdigit(str[pos]))
+ while ((pos < str.length() - 1) && isdigit(str[pos]))
ret += str[pos++];
flag = strToInt(ret);
//#warning old l_getline
#endif
getline(is, str);
- while(str.empty())
+ while (str.empty())
getline(is, str);
}
ret += ch;
ch = ' ';
}
- while((pos < str.length() - 1) && (str[++pos] != ch))
+ while ((pos < str.length() - 1) && (str[++pos] != ch))
ret += str[pos];
return true;
if (cont_row_info[row]) {
DeleteRow(row);
cont_row_info.erase(cont_row_info.begin() + row); //&cont_row_info[row]);
- while(!IsFirstCellInRow(--cell));
+ while (!IsFirstCellInRow(--cell));
} else {
inset = GetCellInset(cell);
continue;
}
int column = column_of_cell(i);
int len = clen[column];
- while(IsPartOfMultiColumn(row, ++column))
+ while (IsPartOfMultiColumn(row, ++column))
len += clen[column] + 4;
print_n_chars(os, ch, len);
if (TopLine(i)) {
}
int column = column_of_cell(i);
int len = clen[column];
- while(IsPartOfMultiColumn(row, ++column))
+ while (IsPartOfMultiColumn(row, ++column))
len += clen[column] + 4;
print_n_chars(os, ch, len);
if (BottomLine(i)) {
int LyXTabular::AsciiPrintCell(Buffer const * buf, ostream & os,
- int cell, int row, int column,
- vector<unsigned int> const & clen) const
+ int cell, int row, int column,
+ vector<unsigned int> const & clen) const
{
ostringstream sstr;
int ret = GetCellInset(cell)->ascii(buf, sstr, 0);
unsigned int len1 = sstr.str().length();
unsigned int len2 = clen[column];
- while(IsPartOfMultiColumn(row, ++column))
+ while (IsPartOfMultiColumn(row, ++column))
len2 += clen[column] + 4;
len2 -= len1;
int dummy_y;
Row * row = getRow(par, pos, dummy_y);
Row * frow = row;
- while(frow->previous() && frow->par() == frow->previous()->par())
+ while (frow->previous() && frow->par() == frow->previous()->par())
frow = frow->previous();
unsigned int maxw = 0;
- while(frow->next() && frow->par() == frow->next()->par()) {
+ while (frow->next() && frow->par() == frow->next()->par()) {
if ((frow != row) && (maxw < frow->width()))
maxw = frow->width();
frow = frow->next();
pos_type first = row->pos();
if (first) { /* hfill *DO* count at the beginning
* of paragraphs! */
- while(first <= last && row->par()->isHfill(first))
+ while (first <= last && row->par()->isHfill(first))
++first;
}
pos_type first = row->pos();
if (first) { /* hfill *DO* count at the beginning
* of paragraphs! */
- while(first < last && row->par()->isHfill(first))
+ while (first < last && row->par()->isHfill(first))
++first;
}
if (inset_owner) {
Row * r = firstrow;
width = max(0,workWidth(bview));
- while(r) {
+ while (r) {
if (r->width() > width)
width = r->width();
r = r->next();
// Check if it is an exception
KmodException l = deadkey_info_.exception_list;
- while(l != 0) {
+ while (l != 0) {
if (l->c == c) {
res = l->data;
break;
// Check if it is an exception
KmodException l = deadkey_info_.exception_list;
- while(l != 0) {
+ while (l != 0) {
if (l->c == c) {
res = l->data;
break;
// Process with tokens
string temp;
- while(res.length() > 0) {
+ while (res.length() > 0) {
res = split(res, temp, TransState::TOKEN_SEP);
insert(temp, text);
}
lyxerr[Debug::LYXVC] << "\tlooking for `" << tmpf << "'" << endl;
string line;
LRegex reg("/(.*)/(.*)/(.*)/(.*)/(.*)");
- while(getline(ifs, line)) {
+ while (getline(ifs, line)) {
lyxerr[Debug::LYXVC] << "\t line: " << line << endl;
if (contains(line, tmpf)) {
// Ok extract the fields.
namespace {
-#if 0
-/* length units
- */
-
-int const num_units = LyXLength::UNIT_NONE;
-
-// I am not sure if "mu" should be possible to select (Lgb)
-char const * unit_name[num_units] = { "sp", "pt", "bp", "dd",
- "mm", "pc", "cc", "cm",
- "in", "ex", "em", "mu",
- "%", "c%", "p%", "l%" };
-
-
-/* The following static items form a simple scanner for
- * length strings, used by isValid[Glue]Length. See comments there.
- */
-double number[4] = { 0, 0, 0, 0 };
-LyXLength::UNIT unit[4] = { LyXLength::UNIT_NONE,
- LyXLength::UNIT_NONE,
- LyXLength::UNIT_NONE,
- LyXLength::UNIT_NONE };
-int number_index;
-int unit_index;
-
-LyXLength::UNIT unitFromString(string const & data)
-{
- int i = 0;
- while (i < num_units && data != unit_name[i])
- ++i;
- return static_cast<LyXLength::UNIT>(i);
-}
-
-#endif
double number[4] = { 0, 0, 0, 0 };
LyXLength::UNIT unit[4] = { LyXLength::UNIT_NONE,
LyXLength::UNIT_NONE,
projects / lyx.git / commitdiff