+2000-01-24 Lars Gullik Bjønnes <larsbj@lyx.org>
+
+ * src/support/LSubstring.C (LSubstring): set pos to string::npos
+ when regex was not found.
+
+ * src/support/lstrings.C (lowercase): use handcoded transform always.
+ (uppercase): ditto
+
+ * src/text.C (Delete): fixed the crash. cursor.par->prev and
+ old_cursor.par->prev could be 0.
+
+ * several files: changed post inc/dec to pre inc/dec
+
+ * src/lastfiles.C (writeFile): use ostream_iterator and copy to
+ write the lastfiles to file.
+
+ * src/BufferView.C (buffer): only show TextCache info when debugging
+ (buffer): ditto
+ (resizeCurrentBuffer): ditto
+ (workAreaExpose): ditto
+
+ * lib/kbd/iso8859-7.cdef: changed to new quoting scheme
+
+ * lib/kbd/iso8859-2.cdef: changed to new quoting scheme
+
+ * src/insets/insetlatexaccent.C (Draw): make the display of UMLAUT
+ a bit better by removing the special case for \i and \j.
+
2000-01-24 Jean-Marc Lasgouttes <Jean-Marc.Lasgouttes@inria.fr>
* src/lyx_main.C (easyParse): remove test for bad comand line
declared in header. On an alpha, long is _not_ the same as int.
* src/support/LOstream.h: add a "using std::flush;"
+
* src/insets/figinset.C: ditto.
2000-01-21 Lars Gullik Bjønnes <larsbj@lyx.org>
the code.
- take advantage of the C++ standard library.
+- we use the preincrement operator whenever possible, it has potential
+ of beeing faster than postincrement. (same goes for decrement)
+- we try to give variables minimal scope.
+
These guidelines should save us a lot of work while cleaning up the code and
help us to have quality code. LyX has been haunted by problems coming from
unfinished projects by people who have left the team. Those problems will
o always try to use POSIX commands.
o switch to use POSIX signals
o make as much as possible of the code reentreanant(?)
- should make it easier to move to threads later.
- o signal slot mechanism (borrowed from GTK-- project)
- better interface, leaner code, typesafe. I have
- been using this for another project and it works
+ should make it easier to move to threads later. Albeit
+ this is not a huge goal we have some parts of the code
+ that would benefit from threads. (forking is not that
+ nice...)
+ o signal slot mechanism
+ We are going to use the signal/slot implementation
+ found in libsigc++. This will hopefully give us better
+ interface, leaner code, typesafe "callbacks". I have
+ been using signal/slots for other projects and it works
like a charm.
o other code rewrites to make multiple buffers/windows
possible, without too much hassle.
- - get rid of most of the global variables.
+ - get rid of most of the global variables. In
+ perticular current_view is a problem.
- non shared variables in shared structures
- (i.e. the cursor in the text class)
o make source documentation better. Remember that the better
we document LyX internals the easier is it for new
developers to begin working on LyX.
the processes can take place.
o pass an inforeceiver around in the object structure.
(this instead of passing minibuffers, and lyxerrors.)
+ o remove code that is never used, or close to never used.
+ Support for reverse video, fast selection and mono
+ video comes to mind.
================
process.
o online configuration
So that users should not need to edit lyxrc
- manualy
+ manualy. This has now been "half" done; it is now
+ possible to save the current configuration with the
+ lyx command "preferences-save". We need to add code so
+ that the preferences can be set from inside LyX too.
o better fontsupport
T1-lib font renderer.
o better latex code quality
# (c) 1996 by Petr Mejzlík, mejzlik@fi.muni.cz
# Modified by Asger Alstrup (not checked, but better)
-161 "\\c{A}" # A cedilla
-162 "\\u{}" # breve
-163 "\\L{}" # L slash
+161 "\c{A}" # A cedilla
+162 "\u{}" # breve
+163 "\L{}" # L slash
#164
-165 "\\q{L}" # L caron
-166 "\\'{S}" # S acute
-167 "\\S{}" # section mark
-168 "\\\"{}" # umlaut
-169 "\\v{S}" # S caron
-170 "\\c{S}" # S cedilla
-171 "\\v{T}" # T caron
-172 "\\'{Z}" # Z acute
-173 "\\-{}" # dash
-174 "\\v{Z}" # Z caron
-175 "\\.{Z}" # Z dot
-176 "\\r{}" # circle
-177 "\\c{a}" # a cedilla
-178 "\\k{}" #
-179 "\\l{}" # l slash
-180 "\\'{}" # acute
-181 "\\q{l}" # l caron
-182 "\\'{s}" # s acute
-183 "\\v{}" # caron
-184 "\\c{}" # cedilla
-185 "\\v{s}" # s caron
-186 "\\c{s}" # s cedilla
-187 "\\q{t}" # t caron
-188 "\\'{z}" # z acute
-189 "\\H{}" #
-190 "\\v{z}" # z caron
-191 "\\.{z}" # z dot
-192 "\\'{R}" # R acute
-193 "\\'{A}" # A acute
-194 "\\^{A}" # A circumflex
-195 "\\u{A}" # A breve
-196 "\\\"{A}" # A umlaut
-197 "\\'{L}" # L acute
-198 "\\'{C}" # C acute
-199 "\\c{C}" # C cedilla
-200 "\\v{C}" # C caron
-201 "\\'{E}" # E acute
-202 "\\k{E}"
-203 "\\\"{E}" # E umlaut
-204 "\\v{E}" # E caron
-205 "\\'{I}" # I acute
-206 "\\^{I}" # I circumflex
-207 "\\v{D}" # D caron
-208 "\\DH{}" #
-209 "\\'{N}" # N acute
-210 "\\v{N}" # N caron
-211 "\\'{O}" # O acute
-212 "\\^{O}" # O circumflex
-213 "\\H{O}" #
-214 "\\\"{O}" # O umlaut
-215 "$\\times$"
-216 "\\v{R}" # R caron
-217 "\\r{U}" # U circle
-218 "\\'{U}" # U acute
-219 "\\H{U}" #
-220 "\\\"{U}" # U umlaut
-221 "\\'{Y}" # Y acute
-222 "\\c{T}" # T cedilla
-223 "\\ss{}" #
-224 "\\'{r}" # r acute
-225 "\\'{a}" # a acute
-226 "\\^{a}" # a circumflex
-227 "\\u{a}" # a breve
-228 "\\\"{a}" # a umlaut
-229 "\\'{l}" # l acute
-230 "\\'{c}" # c acute
-231 "\\c{c}" # c cedilla
-232 "\\v{c}" # c caron
-233 "\\'{e}" # e acute
-234 "\\k{e}" #
-235 "\\\"{e}" # e umlaut
-236 "\\v{e}" # e caron
-237 "\\'{\\i}" # i acute
-238 "\\^{\\i}" # i circumflex
-239 "\\q{d}" # d caron
-240 "\\dh{}" #
-241 "\\'{n}" # n acute
-242 "\\v{n}" # n caron
-243 "\\'{o}" # o acute
-244 "\\^{o}" # o caron
-245 "\\H{o}" #
-246 "\\\"{o}" # o umlaut
-247 "$\\div$"
-248 "\\v{r}" # r caron
-249 "\\r{u}" # u circle
-250 "\\'{u}" # u acute
-251 "\\H{u}" #
-252 "\\\"{u}" # u umlaut
-253 "\\'{y}" # y acute
-254 "\\c{t}" # t cedilla
-255 "\\.{}" # dot
+165 "\q{L}" # L caron
+166 "\'{S}" # S acute
+167 "\S{}" # section mark
+168 "\"{}" # umlaut
+169 "\v{S}" # S caron
+170 "\c{S}" # S cedilla
+171 "\v{T}" # T caron
+172 "\'{Z}" # Z acute
+173 "\-{}" # dash
+174 "\v{Z}" # Z caron
+175 "\.{Z}" # Z dot
+176 "\r{}" # circle
+177 "\c{a}" # a cedilla
+178 "\k{}" #
+179 "\l{}" # l slash
+180 "\'{}" # acute
+181 "\q{l}" # l caron
+182 "\'{s}" # s acute
+183 "\v{}" # caron
+184 "\c{}" # cedilla
+185 "\v{s}" # s caron
+186 "\c{s}" # s cedilla
+187 "\q{t}" # t caron
+188 "\'{z}" # z acute
+189 "\H{}" # doubleacute or hungarian umlaut
+190 "\v{z}" # z caron
+191 "\.{z}" # z dot
+192 "\'{R}" # R acute
+193 "\'{A}" # A acute
+194 "\^{A}" # A circumflex
+195 "\u{A}" # A breve
+196 "\"{A}" # A umlaut
+197 "\'{L}" # L acute
+198 "\'{C}" # C acute
+199 "\c{C}" # C cedilla
+200 "\v{C}" # C caron
+201 "\'{E}" # E acute
+202 "\k{E}"
+203 "\"{E}" # E umlaut
+204 "\v{E}" # E caron
+205 "\'{I}" # I acute
+206 "\^{I}" # I circumflex
+207 "\v{D}" # D caron
+208 "\DH{}" #
+209 "\'{N}" # N acute
+210 "\v{N}" # N caron
+211 "\'{O}" # O acute
+212 "\^{O}" # O circumflex
+213 "\H{O}" #
+214 "\"{O}" # O umlaut
+215 "$\times$"
+216 "\v{R}" # R caron
+217 "\r{U}" # U circle
+218 "\'{U}" # U acute
+219 "\H{U}" #
+220 "\"{U}" # U umlaut
+221 "\'{Y}" # Y acute
+222 "\c{T}" # T cedilla
+223 "\ss{}" #
+224 "\'{r}" # r acute
+225 "\'{a}" # a acute
+226 "\^{a}" # a circumflex
+227 "\u{a}" # a breve
+228 "\"{a}" # a umlaut
+229 "\'{l}" # l acute
+230 "\'{c}" # c acute
+231 "\c{c}" # c cedilla
+232 "\v{c}" # c caron
+233 "\'{e}" # e acute
+234 "\k{e}" #
+235 "\"{e}" # e umlaut
+236 "\v{e}" # e caron
+237 "\'{\i}" # i acute
+238 "\^{\i}" # i circumflex
+239 "\q{d}" # d caron
+240 "\dh{}" #
+241 "\'{n}" # n acute
+242 "\v{n}" # n caron
+243 "\'{o}" # o acute
+244 "\^{o}" # o caron
+245 "\H{o}" #
+246 "\"{o}" # o umlaut
+247 "$\div$"
+248 "\v{r}" # r caron
+249 "\r{u}" # u circle
+250 "\'{u}" # u acute
+251 "\H{u}" #
+252 "\"{u}" # u umlaut
+253 "\'{y}" # y acute
+254 "\c{t}" # t cedilla
+255 "\.{}" # dot
# (c)1997 by Alkis Polyzotis, npoly@dbnet.ece.ntua.gr
#
-182 "\\'{A}" # accented A
-184 "\\'{E}" # accented E
-185 "\\'{H}" # accented H
-186 "\\'{I}" # accented I
-188 "\\'{O}"
-190 "\\'{Y}" # accented Upsilon
-191 "\\'{V}" # accented Omega
-192 "\\'{\\\"{\\i}}" # accented iota with dyalitika
-192 "\\\"{\\'{\\i}}"
+182 "\'{A}" # accented A
+184 "\'{E}" # accented E
+185 "\'{H}" # accented H
+186 "\'{I}" # accented I
+188 "\'{O}"
+190 "\'{Y}" # accented Upsilon
+191 "\'{V}" # accented Omega
+192 "\'{\"{\i}}" # accented iota with dyalitika
+192 "\"{\'{\i}}"
193 "A"
194 "B"
195 "G"
215 "X"
216 "C"
217 "V"
-218 "\\\"{I}"
-219 "\\\"{Y}"
-220 "\\'{a}" # accented alpha
-221 "\\'{e}"
-222 "\\'{h}"
-223 "\\'{\\i}"
-224 "\\'{\\\"{y}}"
-224 "\\\"{\\'{y}}"
+218 "\"{I}"
+219 "\"{Y}"
+220 "\'{a}" # accented alpha
+221 "\'{e}"
+222 "\'{h}"
+223 "\'{\i}"
+224 "\'{\"{y}}"
+224 "\"{\'{y}}"
225 "a"
226 "b"
227 "g"
247 "x"
248 "c"
249 "v"
-250 "\\\"{\\i}"
-251 "\\\"{y}"
-252 "\\'{o}"
-253 "\\'{y}"
-254 "\\'{v}"
+250 "\"{\i}"
+251 "\"{y}"
+252 "\'{o}"
+253 "\'{y}"
+254 "\'{v}"
buffer_->delUser(this);
// Put the old text into the TextCache.
textcache.push_back(text);
- showTextCache("buffer");
+ if (lyxerr.debugging())
+ showTextCache("buffer");
// delete text;
text = 0;
}
updateScrollbar();
fl_redraw_object(work_area);
// Also remove all remaining text's from the testcache.
- showTextCache("buffer delete all");
+ if (lyxerr.debugging())
+ showTextCache("buffer delete all");
while (!textcache.empty()) {
LyXText * tt = textcache.front();
textcache.erase(textcache.begin());
text = *it;
// take it out of textcache.
textcache.erase(it);
- showTextCache("resizeCurrentBuffer");
+ if (lyxerr.debugging())
+ showTextCache("resizeCurrentBuffer");
} else {
text = new LyXText(work_area->w, buffer_);
}
bufferlist.resize();
// Remove all texts from the textcache
- showTextCache("Expose delete all");
+ if (lyxerr.debugging())
+ showTextCache("Expose delete all");
while(!textcache.empty()) {
LyXText * tt = textcache.front();
textcache.erase(textcache.begin());
*
* LyX, The Document Processor
*
- * Copyright (C) 1995 Matthias Ettrich
- * Copyright (C) 1995-1998 The LyX Team.
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-2000 The LyX Team.
*
* ====================================================== */
FontInfo * fi = new FontInfo();
fontinfo[family][series][shape] = fi;
- for (int cfam = 0; cfam < 2; cfam++) {
+ for (int cfam = 0; cfam < 2; ++cfam) {
// Determine family name
switch (family) {
case LyXFont::ROMAN_FAMILY:
default: ;
}
- for (int cser = 0; cser < 4; cser++) {
+ for (int cser = 0; cser < 4; ++cser) {
// Determine series name
switch (series) {
case LyXFont::MEDIUM_SERIES:
default: ;
}
- for (int csha = 0; csha < 2; csha++) {
+ for (int csha = 0; csha < 2; ++csha) {
// Determine shape name
switch (shape) {
case LyXFont::UP_SHAPE:
<< "Desc: " << desc << '\n'
<< "Text: " << errstr << endl;
terr.insertError(line, desc, errstr);
- num_errors++;
+ ++num_errors;
}
} else {
// information messages, TeX warnings and other
retval |= LATEX_ERROR;
lyxerr[Debug::LATEX] << "Build Error." << endl;
// this is not correct yet
- num_errors++;
+ ++num_errors;
}
}
return retval;
retval |= LATEX_ERROR;
lyxerr[Debug::LATEX] << "Build Error." << endl;
// this is not correct yet
- num_errors++;
+ ++num_errors;
}
}
return retval;
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
} else if (token == "\\layout") {
if (!return_par)
return_par = par;
par->start_of_appendix = true;
} else if (token == "\\paragraph_separation") {
tmpret = lex.FindToken(string_paragraph_separation);
- if (tmpret == -1) tmpret++;
+ if (tmpret == -1) ++tmpret;
if (tmpret != LYX_LAYOUT_DEFAULT)
params.paragraph_separation =
static_cast<BufferParams::PARSEP>(tmpret);
params.readGraphicsDriver(lex);
} else if (token == "\\quotes_language") {
tmpret = lex.FindToken(string_quotes_language);
- if (tmpret == -1) tmpret++;
+ if (tmpret == -1) ++tmpret;
if (tmpret != LYX_LAYOUT_DEFAULT) {
InsetQuotes::quote_language tmpl =
InsetQuotes::EnglishQ;
tmpret = lex.FindToken(string_oldpapersize);
#endif
if (tmpret == -1)
- tmpret++;
+ ++tmpret;
else
params.papersize2 = tmpret;
} else if (token == "\\paperpackage") {
tmpret = lex.FindToken(string_paperpackages);
if (tmpret == -1) {
- tmpret++;
+ ++tmpret;
params.paperpackage = BufferParams::PACKAGE_NONE;
} else
params.paperpackage = tmpret;
params.use_amsmath = lex.GetInteger();
} else if (token == "\\paperorientation") {
tmpret = lex.FindToken(string_orientation);
- if (tmpret == -1) tmpret++;
+ if (tmpret == -1) ++tmpret;
if (tmpret != LYX_LAYOUT_DEFAULT)
params.orientation = static_cast<BufferParams::PAPER_ORIENTATION>(tmpret);
} else if (token == "\\paperwidth") {
font.setLyXColor(lex.GetString());
} else if (token == "\\align") {
tmpret = lex.FindToken(string_align);
- if (tmpret == -1) tmpret++;
+ if (tmpret == -1) ++tmpret;
if (tmpret != LYX_LAYOUT_DEFAULT) { // tmpret != 99 ???
tmpret2 = 1;
for (; tmpret > 0; --tmpret)
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
#if 0 // should not be used any more
} else if (tmptok == "Latex") {
// This one is on its way out
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
#endif
#if 0 // should not be used any more
} else if (tmptok == "LatexDel") {
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
#endif
} else if (tmptok == "\\i") {
inset = new InsetLatexAccent;
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
} else if (tmptok == "FormulaMacro") {
inset = new InsetFormulaMacro;
inset->Read(lex);
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
} else if (tmptok == "Formula") {
inset = new InsetFormula;
inset->Read(lex);
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
} else if (tmptok == "Figure") {
inset = new InsetFig(100, 100, this);
inset->Read(lex);
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
#if 0
} else if (tmptok == "Label") {
// Kept for compability. Remove in 0.13.
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
}
#endif
} else if (tmptok == "Info") {
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
} else if (tmptok == "Include") {
inset = new InsetInclude(string(), this);
inset->Read(lex);
par->InsertChar(pos, LyXParagraph::META_INSET);
par->InsertInset(pos, inset);
par->SetFont(pos, font);
- pos++;
+ ++pos;
} else if (tmptok == "LatexCommand") {
InsetCommand inscmd;
inscmd.Read(lex);
if (depth != par->depth) {
if (par->depth > depth) {
while (par->depth > depth) {
- depth++;
+ ++depth;
}
}
else {
while (par->depth < depth) {
- depth--;
+ --depth;
}
}
}
case LyXParagraph::META_NEWLINE:
if (par->table) {
if (par->table->NumberOfCellsInRow(actcell) <= cell) {
- for(j = actpos; j < clen[cell-1];j++)
+ for(j = actpos; j < clen[cell - 1]; ++j)
ofs << ' ';
ofs << " |\n";
for(j = 0; j < depth; ++j)
// "TeX"-Mode on == > SGML-Mode on.
if (c!= '\0')
os << c; // see LaTeX-Generation...
- char_line_count++;
+ ++char_line_count;
} else if (c == LyXParagraph::META_INSET) {
inset = par->GetInset(i);
string tmp_out;
// non-breaking characters
// char is ' '
if (desc_on == 1) {
- char_line_count++;
+ ++char_line_count;
linux_doc_line_break(os, char_line_count, 6);
os << "</tag>";
desc_on = 2;
char_line_count = depth;
if(!style.free_spacing)
- for (j= 0;j< depth;j++)
+ for (j = 0; j < depth; ++j)
file += ' ';
/* parsing main loop */
// "TeX"-Mode on ==> SGML-Mode on.
if (c!= '\0')
file += c;
- char_line_count++;
+ ++char_line_count;
}
else {
string sgml_string;
// non-breaking characters
// char is ' '
if (desc_on == 1) {
- char_line_count++;
+ ++char_line_count;
file += '\n';
file += "</term><listitem><para>";
desc_on = 2;
c = par->GetChar(i);
if (par->table->IsContRow(cell)) {
if (c == LyXParagraph::META_NEWLINE)
- cell++;
+ ++cell;
continue;
}
font2 = par->GetFontSettings(i);
if (par->table->CellHasContRow(cell)>= 0)
par->RoffContTableRows(ofs, i+1, cell);
par->table->RoffEndOfCell(ofs, cell);
- cell++;
+ ++cell;
break;
case LyXParagraph::META_HFILL:
break;
lst += ChangeExtension(insetinc->getContents(), string(), true);
}
}
- pos++;
+ ++pos;
}
par = par->next;
}
while (par){
pos = -1;
while ((inset = par->ReturnNextInsetPointer(pos))){
- for (int i = 0; i < inset->GetNumberOfLabels(); i++) {
+ for (int i = 0; i < inset->GetNumberOfLabels(); ++i) {
if (!lst.empty())
lst += delim;
lst += inset->getLabel(i);
}
- pos++;
+ ++pos;
}
par = par->next;
}
bibkeys += bk;
}
}
- pos++;
+ ++pos;
}
par = par->next;
}
while (par) {
pos = -1;
while ((inset = par->ReturnNextInsetPointer(pos))){
- for (int i = 0; i < inset->GetNumberOfLabels(); i++) {
+ for (int i = 0; i < inset->GetNumberOfLabels(); ++i) {
if (label == inset->getLabel(i)) {
beforeChange();
text->SetCursor(par, pos);
return true;
}
}
- pos++;
+ ++pos;
}
par = par->next;
}
///
string master;
///
- DEPCLEAN *next;
+ DEPCLEAN * next;
};
/** The buffer object.
void setParentName(string const &);
/// Is buffer read-only?
- bool isReadonly() { return read_only; }
+ bool isReadonly() const { return read_only; }
/// Set buffer read-only flag
void setReadonly(bool flag = true) {
sides = LyXTextClass::OneSide;
columns = 1;
pagestyle = "default";
- for(int iter = 0; iter < 4; iter++) {
+ for(int iter = 0; iter < 4; ++iter) {
user_defined_bullets[iter] = temp_bullets[iter]
= ITEMIZE_DEFAULTS[iter];
}
bool Combox::select_text(char const* t)
{
if (!browser || !t) return false;
- for (int i= 1; i<= fl_get_browser_maxline(browser); i++) {
+ for (int i = 1; i <= fl_get_browser_maxline(browser); ++i) {
if (!strcmp(t, fl_get_browser_line(browser, i))) {
select(i);
return true;
// -*- C++ -*-
-#ifndef _CREDITS_H
-#define _CREDITS_H
+#ifndef CREDITS_H
+#define CREDITS_H
void ShowCredits();
void ShowCopyright();
p->broken = true;
}
makeupdatelist(bitmaps[i]);
- gsrunning--;
+ --gsrunning;
runqueue();
pid_handled = true;
}
*
* LyX, The Document Processor
*
- * Copyright (C) 1995 Matthias Ettrich
- * Copyright (C) 1995-1999 The LyX Team.
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-1999 The LyX Team.
*
* ====================================================== */
if (nestdepth == 0) {
state = WS;
} else {
- nestdepth--;
+ --nestdepth;
}
}
if ((state == Option && c == '[') ||
(state == Content && c == '{')) {
- nestdepth++;
+ ++nestdepth;
}
switch (state) {
case Command: tcommand += c; break;
}
+#if 0 // the compiler generated version should be ok.
InsetLatexAccent::InsetLatexAccent(InsetLatexAccent const & other)
: Inset(), contents(other.contents),
candisp(other.candisp),
plusdesc(other.plusdesc),
ic(other.ic)
{}
-
+#endif
InsetLatexAccent::InsetLatexAccent(string const & string)
: contents(string)
if (candisp) {
if (ic == ' ')
max = font.descent('a');
- else
+ else
max = font.descent(ic);
if (plusdesc)
max += 3;
}
case UMLAUT: // umlaut
{
- float tmpadd = y;
- tmpadd += (remdot) ?
- asc / 3.0 :
- asc / 5.0; // if (remdot) -> i or j
float rad = hg / 2.0;
if (rad <= 1.0) {
scr.drawPoint(pgc,
int(x2 - ((4.0 * hg) / 7.0)),
- tmpadd);
+ y);
scr.drawPoint(pgc,
int(x2 + ((4.0 * hg) / 7.0)),
- tmpadd);
+ y);
} else {
rad += .5; // this ensures that f.ex. 1.5 will
// not be rounded down to .5 and then
// converted to int = 0
scr.fillArc(pgc, int(x2 - ((2.0 * hg) / 4.0)),
- tmpadd,
+ y,
rad, rad, 0, 360*64);
scr.fillArc(pgc, int(x2 + ((2.0 * hg) / 4.0)),
- tmpadd,
+ y,
rad, rad, 0, 360*64);
}
break;
InsetLatexAccent();
///
InsetLatexAccent(string const & string);
+#if 0 // the compiler generated version should be ok.
///
InsetLatexAccent(InsetLatexAccent const &);
+#endif
///
int Ascent(LyXFont const & font) const;
///
*
* LyX, The Document Processor
*
- * Copyright (C) 1997-1999 LyX Team
+ * Copyright 1997-1999 LyX Team
*
* ====================================================== */
else {
Language->addto(tex_babel[n]);
Language2->addto(tex_babel[n]);
- n++;
+ ++n;
}
Language->addto(_("other..."));
{
ofstream ofs(filename.c_str());
if (ofs) {
+#if 0
for (Files::const_iterator cit = files.begin();
cit != files.end();
++cit) {
ofs << (*cit) << '\n';
}
+#else
+ // Ok, ok. It is not required to do it this way...but it
+ // is kindo nice and shows the versiality of iterators and
+ // algorithms. I'll leave this in, and if I get reports
+ // about compilations errors I take it out again before
+ // 1.1.4. (Lgb)
+ using std::copy;
+ using std::ostream_iterator;
+ copy(files.begin(), files.end(),
+ ostream_iterator<string>(ofs, "\n"));
+#endif
} else
lyxerr << "LyX: Warning: unable to save LastFiles: "
<< filename << endl;
pos < (labeltype -
textclasslist.TextClass(current_view->buffer()->
params.textclass).maxcounter()) * 4 + 2;
- pos++)
+ ++pos)
line[pos] = ' ';
// Then the labestring
string::size_type i = 0;
while (pos < 199 && i < par->labelstring.length()) {
line[pos] = par->labelstring[i];
- i++;
- pos++;
+ ++i;
+ ++pos;
}
}
c = par->GetChar(i);
if (isprint(c) || c >= 128) {
line[pos] = c;
- pos++;
+ ++pos;
}
++i;
}
#if FL_REVISION > 85
fl_addto_browser_chars(brow, refs.c_str());
int total_lines = fl_get_browser_maxline(brow);
- for (int i = 1; i <= total_lines ; i++) {
+ for (int i = 1; i <= total_lines ; ++i) {
if (fl_get_browser_line(brow, i) == currentstr) {
topline = i;
break;
if (curr_ref.empty())
break;
fl_add_browser_line(brow, curr_ref.c_str());
- ref_num++;
+ ++ref_num;
}
#endif
char *buf = new char [strlen(line)+1];
strcpy(buf, line);
- for(i = LEN_PHONE;(i>0) && (buf[i] == ' ');i--)
+ for(i = LEN_PHONE; (i > 0) && (buf[i] == ' '); --i)
;
- buf[i+1] = 0;
- for(i = LEN_PHONE+LEN_NAME+1;(i>LEN_PHONE) && (buf[i] == ' ');i--)
+ buf[i + 1] = 0;
+ for(i = LEN_PHONE + LEN_NAME + 1; (i > LEN_PHONE) && (buf[i] == ' '); --i)
;
- buf[i+1] = 0;
+ buf[i + 1] = 0;
fl_set_input(fd_xsendfax->Input_Phone, buf);
fl_set_input(fd_xsendfax->Input_Name, buf+LEN_PHONE+1);
fl_set_input(fd_xsendfax->Input_Enterprise, buf+LEN_PHONE+LEN_NAME+2);
if (!strlen(phone))
return;
- char *buf = new char [50+strlen(enterprise)];
+ char * buf = new char [50 + strlen(enterprise)];
sprintf(buf, "%-*.*s %-*.*s %s",
LEN_PHONE, LEN_PHONE, phone,
n = 0;
}
}
- for(i = 1; i <= n; i++) {
+ for(i = 1; i <= n; ++i) {
line = fl_get_browser_line(fd_phonebook->browser, i);
if (!strncmp(buf, line, 46))
break;
n = 0;
}
}
- for(i= 1;i<= n;i++) {
+ for(i = 1; i <= n; ++i) {
line = fl_get_browser_line(fd_phonebook->browser, i);
if (!strncmp(buf, line, 46))
break;
n = 0;
}
}
- for(i= 1;i<= n;i++) {
+ for(i = 1; i <= n; ++i) {
line = fl_get_browser_line(fd_phonebook->browser, i);
fprintf(fp, "%s\n", line);
}
// If we didn't open an environment above, we open one here
if (!env) {
file += '{';
- count++;
+ ++count;
}
file += '\\';
file += LaTeXSizeNames[f.size()];
if (sel == 0)
return string(); // illegal argument
- sel--; // sel 1..., but layout 0...
+ --sel; // sel 1..., but layout 0...
// Pretend we got the name instead.
Dispatch(int(LFUN_LAYOUT),
&& (IsNewline(0)
|| IsLineSeparator(0))){
Erase(0);
- i++;
+ ++i;
}
}
return i;
one (or more) paragraphs with the footnote, and finally
the a paragraph with the text after the footnote. Only the
first paragraph keeps information about layoutparameters, */
- bool IsDummy() const{
+ bool IsDummy() const {
return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous
&& previous->footnoteflag != LyXParagraph::NO_FOOTNOTE);
}
// modified june 1999 by stefano@zool.su.se to send as many bye
// messages as there are clients, each with client's name.
string message;
- for (int i= 0; i<numclients; i++) {
+ for (int i= 0; i<numclients; ++i) {
message = "LYXSRV:" + clients[i] + ":bye\n";
pipes.send(message);
}
string client;
while(*p && *p != ':')
client += char(*p++);
- if(*p == ':') p++;
+ if(*p == ':') ++p;
if(!*p) return;
// --- 3. get function name ---
if(!server_only && *p == ':' && *(++p)) {
while(*p && *p != '\n')
arg += char(*p++);
- if(*p) p++;
+ if(*p) ++p;
}
lyxerr[Debug::LYXSERVER]
int i= 0; //find place in clients[]
while (!serv->clients[i].empty()
&& i<serv->numclients)
- i++;
+ ++i;
serv->clients[i] = client;
serv->numclients++;
buf = "LYXSRV:" + client + ":hello\n";
} else if (cmd == "bye") {
// If clients == 0 maybe we should reset the pipes
// to prevent fake callbacks
- int i; //look if client is registered
- for (i= 0; i<serv->numclients; i++) {
+ int i = 0; //look if client is registered
+ for (; i < serv->numclients; ++i) {
if (serv->clients[i] == client) break;
}
- if (i<serv->numclients) {
+ if (i < serv->numclients) {
serv->numclients--;
serv->clients[i].clear();
lyxerr[Debug::LYXSERVER]
short type = par->GetType();
bool oldf = (type == LM_OT_PARN || type == LM_OT_MPARN);
if (oldf) {
- type--;
+ --type;
if (!label.empty()) {
label.clear();
}
current_view->owner()->getMiniBuffer()->Set(_("No number"));
} else {
- type++;
+ ++type;
current_view->owner()->getMiniBuffer()->Set(_("Number"));
}
par->SetType(type);
np = i;
// lyxerr << "AN[" << x << " " << y << " " << x1 << " " << y1 << "] ";
// lyxerr << "MT[" << a << " " << d << " " << a1 << " " << d1 << "] ";
-// for (i= 0; i<np; i++)
+// for (i = 0; i < np; ++i)
// lyxerr << "XY[" << point[i].x << " " << point[i].y << "] ";
return &point[0];
void Matriz::matmat(matriz_data& a)
{
- int i;
matriz_data c;
- for (i= 0;i<2; i++) {
+ for (int i = 0;i < 2; ++i) {
c[0][i] = a[0][0]*m[0][i] + a[0][1]*m[1][i];
c[1][i] = a[1][0]*m[0][i] + a[1][1]*m[1][i];
}
{
int i= 0;
- while (math_deco_table[i].code && math_deco_table[i].code!= code) i++;
+ while (math_deco_table[i].code && math_deco_table[i].code!= code) ++i;
if (!math_deco_table[i].code) i = -1;
return i;
}
void
MathDotsInset::Draw(int x, int y)
{
- mathed_draw_deco(pm, x+2, y-dh, width-2, ascent, code);
- if (code == LM_vdots||code == LM_ddots) x++;
- if (code!= LM_vdots) y--;
- mathed_draw_deco(pm, x+2, y-dh, width-2, ascent, code);
+ mathed_draw_deco(pm, x + 2, y - dh, width - 2, ascent, code);
+ if (code == LM_vdots || code == LM_ddots) ++x;
+ if (code!= LM_vdots) --y;
+ mathed_draw_deco(pm, x + 2, y - dh, width - 2, ascent, code);
}
void
}
data.setTab(x-tb, tab);
tb = x;
- tab++;
+ ++tab;
limits = false;
data.Next();
} else
short sizex = size;
idx = 0;
- if (size == LM_ST_DISPLAY) size++;
+ if (size == LM_ST_DISPLAY) ++size;
MathParInset::Draw(x+(width-w0)/2, y - des0);
den->Draw(x+(width-w1)/2, y + den->Ascent() + 2 - dh);
size = sizex;
short idxp = idx;
short sizex = size;
idx = 0;
- if (size == LM_ST_DISPLAY) size++;
+ if (size == LM_ST_DISPLAY) ++size;
MathParInset::Metrics();
size = sizex;
w0 = width;
if (sym == LM_oint) {
XDrawArc(fl_display, pm, mathLineGC, x, y-5*width/4, width, width, 0, 23040);
XFlush(fl_display);
- x++;
+ ++x;
}
XDrawString(fl_display, pm, mathGC, x, y, s, ls);
XFlush(fl_display);
{
if (IsFont()) {
fcode = array->bf[pos];
- pos++;
+ ++pos;
}
return array->bf[pos];
}
-byte* MathedIter::GetString(int& len)
+byte * MathedIter::GetString(int& len)
{
if (IsFont()) {
fcode = array->bf[++pos];
- pos++;
+ ++pos;
}
- byte *s = &array->bf[pos];
+ byte * s = &array->bf[pos];
len = pos;
- while (array->bf[pos]>= ' ' && pos<array->last) pos++;
+ while (array->bf[pos] >= ' ' && pos<array->last) ++pos;
len = pos-len;
return s;
MathedInset* MathedIter::GetInset()
{
if (IsInset()) {
- MathedInset* p;
+ MathedInset * p;
my_memcpy(&p, &array->bf[pos+1], sizeof(p));
return p;
} else {
if (array->bf[pos]<' ') {
fcode = -1;
- if (IsTab()) col++;
+ if (IsTab()) ++col;
if (IsCR()) {
col = 0;
- row++;
+ ++row;
}
}
if (IsInset())
pos += sizeof(char*) + 2;
else
- pos++;
+ ++pos;
if (IsFont()) {
fcode = array->bf[pos++];
if (IsFont() && array->bf[pos] == t) {
fcode = t;
- pos++;
+ ++pos;
} else
if (t!= fcode && pos>0 && MathIsFont(array->bf[pos-1])) {
- pos--;
- int k;
- for (k= pos-1; k>= 0 && array->bf[k]>= ' '; k--);
+ --pos;
+ int k = pos - 1;
+ for (; k >= 0 && array->bf[k]>= ' '; --k);
fcode = (k >= 0 && MathIsFont(array->bf[k])) ? array->bf[k]: -1;
}
short f = (array->bf[pos]<' ') ? 0: fcode;
int shift = (t == fcode) ? 1: ((f) ? 3: 2);
if (t == LM_TC_TAB || t == LM_TC_CR) {
- shift--;
+ --shift;
c = t;
if (t == LM_TC_CR) {
- row++;
+ ++row;
col = 0;
} else
- col++;
+ ++col;
}
if (pos < array->last)
bool fg = false;
if (array->bf[pos]>= ' ') {
if (pos> 0 && MathIsFont(array->bf[pos-1]))
- pos--;
+ --pos;
else {
fg = true;
- shift++;
+ ++shift;
}
}
array->Move(pos, shift);
// I assume that both pos and pos2 are legal positions
void MathedIter::join(int pos2)
{
- if (!OK() || pos2<= pos)
+ if (!OK() || pos2 <= pos)
return;
- short f= fcode;
- if (pos>0 && array->bf[pos]>= ' ' && MathIsFont(array->bf[pos-1]))
- pos--;
+ short f = fcode;
+ if (pos > 0 && array->bf[pos] >= ' ' && MathIsFont(array->bf[pos-1]))
+ --pos;
if (MathIsFont(array->bf[pos2-1]))
- pos2--;
+ --pos2;
- if (array->bf[pos2]>= ' ') {
- for (int p= pos2; p>0; p--)
+ if (array->bf[pos2] >= ' ') {
+ for (int p = pos2; p > 0; --p)
if (MathIsFont(array->bf[p])) {
f = array->bf[p];
break;
if (MathIsFont(array->bf[pos-1]) && array->bf[pos+1]<' ') {
int i;
shift = 2;
- pos--;
- for (i= pos-1; i>0 && !MathIsFont(array->bf[i]); i--);
+ --pos;
+ for (i = pos - 1; i > 0 && !MathIsFont(array->bf[i]); --i);
if (i>0 && MathIsFont(array->bf[i]))
fcode = array->bf[i];
} else
shift = sizeof(char*) + 2;
else
if (c == LM_TC_TAB || c == LM_TC_CR) {
- shift++;
+ ++shift;
// lyxerr <<"Es un tab.";
}
else {
// int posx = pos;
ipush();
- LyxArrayBase *t= array, *a;
+ LyxArrayBase * t = array, *a;
- if (pos1>0 || pos2<= array->last) {
+ if (pos1 > 0 || pos2 <= array->last) {
short fc= 0;
if (pos1>0 && array->bf[pos1]>' ') {
- for (int p= pos1; p>= 0; p--)
+ for (int p = pos1; p >= 0; --p)
if (MathIsFont(array->bf[p])) {
if (p!= pos1-1)
fc = array->bf[p];
else
- pos1--;
+ --pos1;
break;
}
}
- if (pos2>0 && array->bf[pos2]>= ' ' && MathIsFont(array->bf[pos2-1]))
- pos2--;
+ if (pos2 > 0 && array->bf[pos2] >= ' '
+ && MathIsFont(array->bf[pos2-1]))
+ --pos2;
int dx = pos2 - pos1;
a = new LyxArrayBase(dx+LyxArrayBase::ARRAY_MIN_SIZE);
my_memcpy(&a->bf[(fc) ? 1: 0], &array->bf[pos1], dx);
if (fc) {
a->bf[0] = fc;
- dx++;
+ ++dx;
}
a->last = dx;
a->bf[dx] = '\0';
if (p) {
crow = p->getRowSt();
if (crow)
- for (int i= 0; i<row; i++)
+ for (int i = 0; i < row; ++i)
crow = crow->next;
}
}
/* int k = tmplate->getMacroPar(i)->GetColumns();
if (k>0) {
args[i].array = new LyxArrayBase;
- for (int j= 0; j<k-1; j++) args[i].array->Insert(j, LM_TC_TAB);
+ for (int j= 0; j<k-1; ++j) args[i].array->Insert(j, LM_TC_TAB);
}*/
}
idx = 0;
MathParInset(LM_ST_TEXT, nm, LM_OT_MACRO),
flags(flg), nargs(na)
{
- if (nargs>0) {
+ if (nargs > 0) {
tcode = LM_TC_ACTIVE_INSET;
args = new MathMacroArgument[nargs];
- for (int i= 0; i<nargs; i++) {
- args[i].setNumber(i+1);
+ for (int i = 0; i < nargs; ++i) {
+ args[i].setNumber(i + 1);
}
} else
tcode = LM_TC_INSET;
MathMacroTemplate::~MathMacroTemplate()
{
// prevent to delete already deleted objects
- for (int i= 0; i<nargs; i++) {
+ for (int i = 0; i < nargs; ++i) {
args[i].SetData(0);
}
delete[] args;
bool expnd = (nargs>0) ? args[0].getExpand(): false;
if (flags & MMF_Edit) {
- for (int i= 0; i<nargs; i++) {
+ for (int i = 0; i < nargs; ++i) {
args[i].setExpand(false);
}
} else {
- for (int i= 0; i<nargs; i++) {
+ for (int i = 0; i < nargs; ++i) {
args[i].setExpand(true);
}
}
MathParInset::Metrics();
- for (int i= 0; i<nargs; i++) {
+ for (int i = 0; i < nargs; ++i) {
args[i].setExpand(expnd);
}
}
void MathMacroTemplate::update(MathMacro * macro)
{
int idx = (macro) ? macro->getArgumentIdx(): 0;
- for (int i= 0; i<nargs; i++) {
+ for (int i = 0; i < nargs; ++i) {
if (macro) {
macro->setArgumentIdx(i);
args[i].SetData(macro->GetData());
case 2:
{
int nx = int(fl_get_slider_value(fd_matrix->columns)+0.5);
- for (int i= 0; i<nx; i++) h_align_str[i] = 'c';
+ for (int i = 0; i < nx; ++i) h_align_str[i] = 'c';
//memset(h_align_str, 'c', nx);
h_align_str[nx] = '\0';
// fl_freeze_form(fd_form_main->form_main);
*p = c;
yyis->get(cc);
c = cc;
- p++;
+ ++p;
}
*p = '\0';
if (yyis->good()) yyis->putback(c);
if (l->token == LM_TK_BEGIN || l->token == LM_TK_END) {
int i;
LexGetArg('{');
-// for (i= 0; i<5 && strncmp(yytext, latex_mathenv[i],
-// strlen(latex_mathenv[i])); i++);
+// for (i = 0; i < 5 && strncmp(yytext, latex_mathenv[i],
+// strlen(latex_mathenv[i])); ++i);
- for (i = 0; i < 6 && strcmp(yytext, latex_mathenv[i]); i++);
+ for (i = 0; i < 6 && strcmp(yytext, latex_mathenv[i]); ++i);
yylval.i = i;
} else
if (l->token == LM_TK_SPACE)
}
case LM_TK_OPEN:
{
- brace++;
+ ++brace;
if (accent && tprev == LM_TK_ACCENT) {
acc_braces[acc_brace++] = brace;
break;
}
case LM_TK_CLOSE:
{
- brace--;
+ --brace;
if (brace < 0) {
mathPrintError("Unmatching braces");
panic = true;
break;
}
if (acc_brace && brace == acc_braces[acc_brace-1]-1) {
- acc_brace--;
+ --acc_brace;
break;
}
if (flags & FLAG_BRACE_FONT) {
break;
}
if (brace == 0 && (flags & FLAG_BRACE_LAST)) {
- plevel--;
+ --plevel;
return array;
} else {
data.Insert ('}', LM_TC_TEX);
case ']':
{
if (flags & FLAG_BRACK_END) {
- plevel--;
+ --plevel;
return array;
} else
data.Insert (']');
case LM_TK_RIGHT:
{
if (flags & FLAG_RIGHT) {
- plevel--;
+ --plevel;
return array;
} else {
mathPrintError("Unmatched right delimiter");
data.Insert(doAccent(p), p->getTCode());
else
data.Insert(p, p->getTCode());
- for (int i = 0; p->setArgumentIdx(i); i++)
+ for (int i = 0; p->setArgumentIdx(i); ++i)
p->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
}
else {
// debug info [made that conditional -JMarc]
if (lyxerr.debugging(Debug::MATHED))
lyxerr << "[" << yylval.i << "]" << endl;
- plevel--;
+ --plevel;
if (mt) { // && (flags & FLAG_END)) {
mt->SetData(array);
array = 0;
data.Insert(p, p->getTCode());
p->setArgumentIdx(0);
mathed_parse(FLAG_END, p->GetData(), reinterpret_cast<MathParInset**>(&p));
-// for (int i= 0; p->setArgumentIdx(i); i++)
+// for (int i = 0; p->setArgumentIdx(i); ++i)
// p->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
} else
mathPrintError("Unrecognized environment");
break;
}
}
- plevel--;
+ --plevel;
return array;
}
void BitmapMenu::Create()
{
- if (i<nb) {
+ if (i < nb) {
lyxerr << "Error: Bitmaps not created!" << endl;
return;
}
form = fl_bgn_form(FL_UP_BOX, w, h);
- for (i= 0; i<nb; i++) {
+ for (i = 0; i < nb; ++i) {
fl_add_object(form, bitmap[i]);
bitmap[i]->u_vdata = this;
}
{
if (active == this) {
int k = 0;
- for (i= 0; i<nb; i++) {
+ for (i = 0; i < nb; ++i) {
if (bitmap[i] == ob)
return k+fl_get_bmtable(ob);
k += fl_get_bmtable_maxitems(bitmap[i]);
case 5: latex_str = latex_misc; break;
}
- for (int k = 0; latex_str[k][0]>' '; k++) {
+ for (int k = 0; latex_str[k][0] > ' '; ++k) {
if (strcmp(latex_str[k], s) == 0) {
id = k;
break;
(data.FCode() == LM_TC_SPECIAL))
outf += '\\';
else {
- if (*s == '{') brace++;
- if (*s == '}') brace--;
+ if (*s == '{') ++brace;
+ if (*s == '}') --brace;
}
if (*s == '}' && data.FCode() == LM_TC_TEX && brace<0)
lyxerr <<"Math warning: Unexpected closing brace."
else
outf += char(*s);
}
- s++; ls--;
+ ++s; --ls;
}
if (data.FCode()>= LM_TC_RM && data.FCode()<= LM_TC_TEXTRM)
outf += '}';
crow = crow->getNext();
}
outf += "\\\\\n";
- number_of_newlines++;
+ ++number_of_newlines;
data.Next();
break;
}
}
while (brace>0) {
outf += '}';
- brace--;
+ --brace;
}
}
outf += '{';
outf += h_align;
outf += "}\n";
- number_of_newlines++;
+ ++number_of_newlines;
}
MathParInset::Write(outf);
if (GetType() == LM_OT_MATRIX){
outf += "\n\\end{";
outf += name;
outf += '}';
- number_of_newlines++;
+ ++number_of_newlines;
}
}
// Modified to work in a cleaner and hopefully more general way
// (JMarc)
outf += "\n";
- number_of_newlines++;
+ ++number_of_newlines;
}
if (mathed_env == LM_EN_DISPLAY){
outf += "\\[\n";
outf += latex_mathenv[mathed_env];
outf += "}\n";
}
- number_of_newlines++;
+ ++number_of_newlines;
}
if (label && label[0]>' ' && mathed_env == LM_EN_EQUATION){
outf += "\\label{";
outf += label;
outf += "}\n";
- number_of_newlines++;
+ ++number_of_newlines;
}
p->Write(outf);
}
else if (mathed_env == LM_EN_DISPLAY){
outf += "\\]\n";
- number_of_newlines++;
+ ++number_of_newlines;
}
else {
outf += "\n\\end{";
outf += latex_mathenv[mathed_env];
outf += "}\n";
- number_of_newlines+= 2;
+ number_of_newlines += 2;
}
*newlines = number_of_newlines;
}
fl_setpup_shortcut(InsertMenu, 17, scex(_("IM|Uu#u#U")));
if (tmpbuffer->isReadonly()) {
- for (int ii = 1; ii <= 16; ii++)
+ for (int ii = 1; ii <= 16; ++ii)
fl_setpup_mode(InsertMenu, ii, FL_PUP_GREY);
fl_setpup_mode(InsertMenu, 17, FL_PUP_GREY);
}
fl_setpup_shortcut(MathMenu, 9, scex(_("MM|Pp#p#P")));
if (tmpbuffer->isReadonly())
- for (int ii = 1; ii <= 9; ii++)
+ for (int ii = 1; ii <= 9; ++ii)
fl_setpup_mode(MathMenu, ii, FL_PUP_GREY);
void addHistory(string const &cmd) {
if (history_cnt == 0 || (history_cnt>0 && cmd!= history[(history_cnt-1) % MAX_HISTORY])) {
history[history_cnt % MAX_HISTORY] = cmd;
- history_cnt++;
+ ++history_cnt;
}
history_idx = history_cnt;
}
*
* LyX, the High Level Word Processor
*
- * Copyright (C) 1995Matthias Ettrich
- * Copyright (C) 1995-1998 The LyX Team.
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-1998 The LyX Team.
*
* ======================================================
A few prototypes and definitions needed for Windows NT */
if (depth > dth) {
while (depth > dth) {
os << "\n\\begin_deeper ";
- dth++;
+ ++dth;
}
}
else {
while (depth < dth) {
os << "\n\\end_deeper ";
- dth--;
+ --dth;
}
}
}
font1 = LyXFont(LyXFont::ALL_INHERIT);
column = 0;
- for (size_type i = 0; i < size(); i++) {
- if (!i){
+ for (size_type i = 0; i < size(); ++i) {
+ if (!i) {
os << "\n";
column = 0;
}
else
lyxerr << "ERROR (LyXParagraph::writeFile):"
" NULL char in structure." << endl;
- column++;
+ ++column;
break;
}
}
int firstpos = lastpos;
while ((firstpos >= 0) && !IsLetter(firstpos))
- firstpos--;
+ --firstpos;
// now find the beginning by looking for a nonletter
// to the new paragraph
pos_first = 0;
while (ParFromPos(pos_first) != par)
- pos_first++;
+ ++pos_first;
pos_end = pos_first + par->text.size() - 1;
// The constructor has already reserved 500 elements
//if (pos_end > pos)
// tmp->text.reserve(pos_end - pos);
- for (i = pos; i <= pos_end; i++) {
+ for (i = pos; i <= pos_end; ++i) {
par->CutIntoMinibuffer(i - pos_first);
tmp->InsertFromMinibuffer(i - pos);
}
tmp->text.resize(tmp->text.size());
- for (i = pos_end; i >= pos; i--)
+ for (i = pos_end; i >= pos; --i)
par->Erase(i - pos_first);
par->text.resize(par->text.size());
// copy everything behind the break-position to the new paragraph
- for (size_type i = 0; i < size(); i++) {
+ for (size_type i = 0; i < size(); ++i) {
CopyIntoMinibuffer(i);
result->InsertFromMinibuffer(i);
}
size_type pos_end = the_next->text.size() - 1;
size_type pos_insert = Last();
- size_type i;
// ok, now copy the paragraph
- for (i = 0; i <= pos_end; i++) {
+ for (size_type i = 0; i <= pos_end; ++i) {
the_next->CutIntoMinibuffer(i);
InsertFromMinibuffer(pos_insert + i);
}
tmpi = tmpi->next;
if (tmpi2->inset) {
if (tmpi2->inset->AutoDelete()) {
- i++;
+ ++i;
Erase(tmpi2->pos);
}
} else {
&& !IsDummy()) {
if (style.isCommand()) {
file += '{';
- column++;
+ ++column;
} else if (align != LYX_ALIGN_LAYOUT) {
file += '{';
- column++;
+ ++column;
return_value = true;
}
}
for (size_type i = 0; i < size(); ++i) {
char c = GetChar(i);
- if (table->IsContRow(current_cell_number+1)) {
+ if (table->IsContRow(current_cell_number + 1)) {
if (c == LyXParagraph::META_NEWLINE)
- current_cell_number++;
+ ++current_cell_number;
continue;
}
++column;
}
basefont = getFont(-1);
running_font = basefont;
- current_cell_number++;
+ ++current_cell_number;
if (table->CellHasContRow(current_cell_number) >= 0) {
- TeXContTableRows(file, i+1,
+ TeXContTableRows(file, i + 1,
current_cell_number,
column, texrow);
}
// put the EndOfCell because it is put after the
// for(...)
if (table->ShouldBeVeryLastCell(current_cell_number)) {
- current_cell_number--;
+ --current_cell_number;
break;
}
int tmp = table->TexEndOfCell(file,
current_cell_number);
- if (tmp>0) {
+ if (tmp > 0) {
column = 0;
} else if (tmp < 0) {
tmp = -tmp;
}
- for (;tmp--;) {
+ for (; tmp--;) {
texrow.newline();
}
- texrow.start(this, i+1);
+ texrow.start(this, i + 1);
} else {
SimpleTeXSpecialChars(file, texrow,
font, running_font, basefont,
if (open_font) {
running_font.latexWriteEndChanges(file, basefont);
}
- current_cell_number++;
+ ++current_cell_number;
tmp = table->TexEndOfCell(file, current_cell_number);
for (; tmp > 0; --tmp)
texrow.newline();
for (; (i < size()) && (current_cell_number<cell); ++i) {
c = GetChar(i);
if (c == LyXParagraph::META_NEWLINE)
- current_cell_number++;
+ ++current_cell_number;
}
lastpos = i;
c = GetChar(i);
emph_flag= false;
}
font1 = font2 = getFont(-1);
- current_cell_number++;
+ ++current_cell_number;
if (table->CellHasContRow(current_cell_number) >= 0) {
DocBookContTableRows(file, extra, desc_on, i+1,
current_cell_number,
// put the EndOfCell because it is put after the
// for(...)
if (table->ShouldBeVeryLastCell(current_cell_number)) {
- current_cell_number--;
+ --current_cell_number;
break;
}
- tmp= table->DocBookEndOfCell(file, current_cell_number,
- depth);
+ tmp = table->DocBookEndOfCell(file,
+ current_cell_number,
+ depth);
if (tmp > 0)
column = 0;
// non-breaking characters
// char is ' '
if (desc_on == 1) {
- char_line_count++;
+ ++char_line_count;
file += '\n';
file += "</term><listitem><para>";
desc_on = 2;
for (; i < size() && current_cell_number < cell; ++i) {
c = GetChar(i);
if (c == LyXParagraph::META_NEWLINE)
- current_cell_number++;
+ ++current_cell_number;
}
lastpos = i;
c = GetChar(i);
// non-breaking characters
// char is ' '
if (desc_on == 1) {
- char_line_count++;
+ ++char_line_count;
file += '\n';
file += "</term><listitem><para>";
desc_on = 2;
} else {
column += file.length() - len;
}
- for (;tmp--;) {
+ for (; tmp--;) {
texrow.newline();
}
}
// free the memory used by string::copy in the
// setup of argv
- for (int i= 0; i < argc -1; i++)
+ for (int i= 0; i < argc -1; ++i)
delete[] argv[i];
lyxerr << "LyX: Failed to start ispell!" << endl;
if (count) result->misses = new char*[count];
p = strpbrk(nb, ":");
p += 2;
- for (i = 0; i<count; i++) {
+ for (i = 0; i < count; ++i) {
result->misses[i] = p;
p = strpbrk(p, ",\n");
*p = 0;
- p+= 2;
+ p += 2;
}
break;
}
while (true) {
word = current_view->nextWord(newval);
if (word == 0) break;
- word_count++;
+ ++word_count;
// Update slider if and only if value has changed
newvalue = int(100.0*newval);
fl_set_object_label(fd_form_spell_check->text, word);
fl_set_input(fd_form_spell_check->input, word);
fl_clear_browser(fd_form_spell_check->browser);
- for (i= 0; i<result->count; i++) {
+ for (i = 0; i < result->count; ++i) {
fl_add_browser_line(fd_form_spell_check->browser, result->misses[i]);
}
}
+// should not be in FileInfo
char const * FileInfo::typeIndicator() const
{
if (S_ISDIR(buf.st_mode)) return ("/");
return buf.st_mode;
}
+
long FileInfo::getBlockSize() const
{
#ifndef __EMX__
#endif
}
+
+// should not be in FileInfo
void FileInfo::modeString(char * szString) const
{
szString[0] = typeLetter();
}
+// should not be in FileInfo
char FileInfo::typeLetter() const
{
#ifdef S_ISBLK
}
+// should not be in FileInfo
void FileInfo::flagRWX(unsigned short i, char * szString) const
{
szString[0] = (i & S_IRUSR) ? 'r' : '-';
}
+// should not be in FileInfo
void FileInfo::setSticky(char * szString) const
{
#ifdef S_ISUID
}
-time_t FileInfo::getStatusChangeTime() const
+time_t FileInfo::getStatusChangeTime() const
{
return buf.st_ctime;
}
}
+// should not be in FileInfo
bool FileInfo::access(int p)
{
// if we don't have a filename we fail
pos = res.first;
} else {
n = 0;
- pos = 0;
+ pos = string::npos;
}
}
string lowercase(string const & a)
{
string tmp(a);
-#ifdef __GLIBCPP__
+//#ifdef __GLIBCPP__
string::iterator result = tmp.begin();
for (string::iterator first = tmp.begin();
first != tmp.end(); ++first, ++result) {
*result = tolower(*first);
}
-#else
- transform(tmp.begin(), tmp.end(), tmp.begin(), tolower);
-#endif
+//#else
+// transform(tmp.begin(), tmp.end(), tmp.begin(), tolower);
+//#endif
return tmp;
}
string uppercase(string const & a)
{
string tmp(a);
-#ifdef __GLIBCPP__
+//#ifdef __GLIBCPP__
string::iterator result = tmp.begin();
for (string::iterator first = tmp.begin();
first != tmp.end(); ++first, ++result) {
*result = toupper(*first);
}
-#else
- transform(tmp.begin(), tmp.end(), tmp.begin(), toupper);
-#endif
+//#else
+// transform(tmp.begin(), tmp.end(), tmp.begin(), toupper);
+//#endif
return tmp;
}
Startcontroller();
~Startcontroller();
static SystemcallsSingletoncontroller * getController();
- void reduceRefcount() { refcount--; }
+ void reduceRefcount() { --refcount; }
private:
static SystemcallsSingletoncontroller * contr;
static int refcount;
// Create the global controller
contr = new SystemcallsSingletoncontroller;
}
- refcount++;
+ ++refcount;
return contr;
}
while (column
&& cell_info[row-1][column].multicolumn
== LyXTable::CELL_PART_OF_MULTICOLUMN)
- column--;
+ --column;
if (cell_info[row-1][column].multicolumn
== LyXTable::CELL_NORMAL)
return row_info[row-1].bottom_line;
int LyXTable::AdditionalHeight(int cell)
{
int row = row_of_cell(cell);
- int top = 1;
- int bottom = 1;
+ if (!row) return 0;
+
+ int top = 1; // bool top = true; ??
+ int bottom = 1; // bool bottom = true; ??
int column;
- if (row){
- for (column = 0;column < columns-1 && bottom;column++){
- switch (cell_info[row-1][column].multicolumn){
- case LyXTable::CELL_BEGIN_OF_MULTICOLUMN:
- bottom = cell_info[row-1][column].bottom_line;
- break;
- case LyXTable::CELL_NORMAL:
- bottom = row_info[row-1].bottom_line;
- }
+
+ for (column = 0; column < columns - 1 && bottom; ++column) {
+ switch (cell_info[row - 1][column].multicolumn) {
+ case LyXTable::CELL_BEGIN_OF_MULTICOLUMN:
+ bottom = cell_info[row - 1][column].bottom_line;
+ break;
+ case LyXTable::CELL_NORMAL:
+ bottom = row_info[row - 1].bottom_line;
}
- for (column = 0;column < columns-1 && top;column++){
- switch (cell_info[row][column].multicolumn){
- case LyXTable::CELL_BEGIN_OF_MULTICOLUMN:
- top = cell_info[row][column].top_line;
- break;
- case LyXTable::CELL_NORMAL:
- top = row_info[row].top_line;
- }
+ }
+ for (column = 0; column < columns - 1 && top; ++column) {
+ switch (cell_info[row][column].multicolumn){
+ case LyXTable::CELL_BEGIN_OF_MULTICOLUMN:
+ top = cell_info[row][column].top_line;
+ break;
+ case LyXTable::CELL_NORMAL:
+ top = row_info[row].top_line;
}
- if (top && bottom)
- return WIDTH_OF_LINE;
}
+ if (top && bottom)
+ return WIDTH_OF_LINE;
return 0;
}
{
int column1 = column_of_cell(cell);
int column2 = right_column_of_cell(cell);
- int i;
int result = 0;
- for (i = column1; i<= column2;i++){
+ int i = column1;
+ for (; i <= column2; ++i) {
result += column_info[i].width_of_column;
}
return result;
int row = row_of_cell(cell);
int column1 = column_of_cell(cell);
int column2 = right_column_of_cell(cell);
- int i;
- int width = 0;
// first set columns to 0 so we can calculate the right width
- for (i = column1; i<= column2;i++) {
+ int i = column1;
+ for (; i <= column2; ++i) {
cell_info[row][i].width_of_cell = 0;
}
// set the width to MAX_WIDTH until width > 0
- width = (new_width + 2*WIDTH_OF_LINE);
- for (i = column1; (i<column2) && (width > 0);i++){
+ int width = (new_width + 2 * WIDTH_OF_LINE);
+ for (i = column1; (i < column2) && (width > 0); ++i) {
cell_info[row][i].width_of_cell = column_info[i].width_of_column;
width -= column_info[i].width_of_column;
}
return true;
}
+
void LyXTable::recalculateMulticolCells(int cell, int new_width)
{
- int
- row = row_of_cell(cell),
- column1 = column_of_cell(cell),
- column2 = right_column_of_cell(cell),
- i;
+ int row = row_of_cell(cell);
+ int column1 = column_of_cell(cell);
+ int column2 = right_column_of_cell(cell);
// first set columns to 0 so we can calculate the right width
- for (i = column1; i<= column2;++i)
+ int i = column1;
+ for (; i <= column2; ++i)
cell_info[row][i].width_of_cell = 0;
- for(i = cell+1;(i<numberofcells) && (!IsMultiColumn(i));++i)
+ for(i = cell + 1; (i < numberofcells) && (!IsMultiColumn(i)); ++i)
;
if (i < numberofcells)
- recalculateMulticolCells(i, GetWidthOfCell(i)-(2*WIDTH_OF_LINE));
+ recalculateMulticolCells(i, GetWidthOfCell(i) - (2 * WIDTH_OF_LINE));
SetWidthOfMulticolCell(cell, new_width);
}
+
/* returns 1 if a complete update is necessary, otherwise 0 */
bool LyXTable::SetWidthOfCell(int cell, int new_width)
{
int row = row_of_cell(cell);
int column1 = column_of_cell(cell);
int column2 = right_column_of_cell(cell);
- int i;
int result = 0;
- for (i = column1; i<= column2;i++){
+ int i = column1;
+ for (; i <= column2; ++i) {
result += cell_info[row][i].width_of_cell;
}
bool LyXTable::IsLastCell(int cell)
{
- return (right_column_of_cell(cell) == (columns-1));
+ return (right_column_of_cell(cell) == (columns - 1));
}
bool LyXTable::calculate_width_of_column(int column)
{
- int i, max;
int old_column_width = column_info[column].width_of_column;
- max = 0;
- for (i = 0; i<rows; i++) {
- if (cell_info[i][column].width_of_cell > max) {
- max = cell_info[i][column].width_of_cell;
- }
+ int maximum = 0;
+ for (int i = 0; i < rows; ++i) {
+ maximum = max(cell_info[i][column].width_of_cell, maximum);
}
- column_info[column].width_of_column = max;
+ column_info[column].width_of_column = maximum;
return (column_info[column].width_of_column != old_column_width);
}
bool LyXTable::calculate_width_of_column_NMC(int column)
{
- int i, max;
int old_column_width = column_info[column].width_of_column;
- max = 0;
- for (i = 0; i<rows; ++i) {
+ int max = 0;
+ for (int i = 0; i < rows; ++i) {
if (!IsMultiColumn(GetCellNumber(column, i)) &&
(cell_info[i][column].width_of_cell > max)) {
max = cell_info[i][column].width_of_cell;
int column = column_of_cell(cell);
while (column < columns - 1 &&
cell_info[row][column+1].multicolumn == LyXTable::CELL_PART_OF_MULTICOLUMN)
- column++;
+ ++column;
return column;
}
file += '}';
if (RotateCell(cell)) {
file += "\n\\end{sideways}";
- ret++;
+ ++ret;
}
file += "\\\\\n";
- ret++;
+ ++ret;
tmp = 0;
fcell = cell;
- while (!IsFirstCell(fcell))fcell--;
- for (i = 0; i < NumberOfCellsInRow(fcell); i++){
- if (BottomLine(fcell+i))
- tmp++;
+ while (!IsFirstCell(fcell)) --fcell;
+ for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
+ if (BottomLine(fcell + i))
+ ++tmp;
}
- if (tmp == NumberOfCellsInRow(fcell)){
+ if (tmp == NumberOfCellsInRow(fcell)) {
file += "\\hline ";
} else {
tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); i++){
- if (BottomLine(fcell+i)){
+ for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
+ if (BottomLine(fcell + i)) {
file += "\\cline{";
- file += tostr(column_of_cell(fcell+i)+1);
+ file += tostr(column_of_cell(fcell + i) + 1);
file += '-';
- file += tostr(right_column_of_cell(fcell+i)+1);
+ file += tostr(right_column_of_cell(fcell + i) + 1);
file += "} ";
tmp = 1;
}
}
if (tmp){
file += '\n';
- ret++;
+ ++ret;
}
if (is_long_table)
file += "\\end{longtable}";
file += "\\end{tabular}";
if (rotate) {
file += "\n\\end{sideways}";
- ret++;
+ ++ret;
}
} else {
- nvcell = NextVirtualCell(cell+1);
+ nvcell = NextVirtualCell(cell + 1);
if (cell < 0){
// preamble
if (rotate) {
file += "\\begin{sideways}\n";
- ret++;
+ ++ret;
}
if (is_long_table)
file += "\\begin{longtable}{";
else
file += "\\begin{tabular}{";
- for (i = 0; i<columns;i++){
+ for (i = 0; i < columns; ++i) {
if (column_info[i].left_line)
file += '|';
if (!column_info[i].align_special.empty()) {
file += '|';
}
file += "}\n";
- ret++;
+ ++ret;
tmp = 0;
- if (GetNumberOfCells()){
+ if (GetNumberOfCells()) {
fcell = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); i++){
- if (TopLine(fcell+i))
- tmp++;
+ for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
+ if (TopLine(fcell + i))
+ ++tmp;
}
if (tmp == NumberOfCellsInRow(fcell)){
file += "\\hline ";
} else {
tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); i++){
- if (TopLine(fcell+i)){
+ for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
+ if (TopLine(fcell + i)) {
file += "\\cline{";
- file += tostr(column_of_cell(fcell+i)+1);
+ file += tostr(column_of_cell(fcell + i) + 1);
file += '-';
- file += tostr(right_column_of_cell(fcell+i)+1);
+ file += tostr(right_column_of_cell(fcell + i) + 1);
file += "} ";
tmp = 1;
}
}
if (tmp){
file += '\n';
- ret++;
+ ++ret;
}
}
if (RotateCell(0)) {
file += "\\begin{sideways}\n";
- ret++;
+ ++ret;
}
} else {
// usual cells
}
if (RotateCell(cell)) {
file += "\n\\end{sideways}";
- ret++;
+ ++ret;
}
if (IsLastCell(cell)) {
int row = row_of_cell(cell);
string hline1, hline2;
bool print_hline = true;
- bool pr_top_hline, flag1, flag2;
- flag1 = IsLongTable() &&
+ bool flag1 = IsLongTable() &&
((row == endhead) || (row == endfirsthead) ||
(row == endfoot) || (row == endlastfoot));
- row++;
- flag2 = IsLongTable() &&
+ ++row;
+ bool flag2 = IsLongTable() &&
((row <= endhead) || (row <= endfirsthead) ||
(row <= endfoot) || (row <= endlastfoot));
- row--;
+ --row;
// print the bottom hline only if (otherwise it is doubled):
// - is no LongTable
// - there IS a first-header
// & this row is no special header/footer
// - the next row is a special header/footer
// & this row is a special header/footer
- pr_top_hline = (flag1 && flag2) || (!flag1 && !flag2) ||
+ bool pr_top_hline = (flag1 && flag2) || (!flag1 && !flag2) ||
(endfirsthead == endhead);
file += "\\\\\n";
- ret++;
+ ++ret;
tmp = 0;
fcell = cell;
while (!IsFirstCell(fcell))
- fcell--;
- for (i = 0; i < NumberOfCellsInRow(cell); i++){
- if (BottomLine(fcell+i))
- tmp++;
+ --fcell;
+ for (i = 0; i < NumberOfCellsInRow(cell); ++i) {
+ if (BottomLine(fcell + i))
+ ++tmp;
}
if (tmp == NumberOfCellsInRow(cell)){
file += "\\hline ";
hline1 = "\\hline ";
} else {
tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); i++){
- if (BottomLine(fcell+i)){
+ for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
+ if (BottomLine(fcell + i)){
file += "\\cline{";
- file += tostr(column_of_cell(fcell+i)+1);
+ file += tostr(column_of_cell(fcell + i) + 1);
file += '-';
- file += tostr(right_column_of_cell(fcell+i)+1);
+ file += tostr(right_column_of_cell(fcell + i) + 1);
file += "} ";
hline1 += "\\cline{";
- hline1 += tostr(column_of_cell(fcell+i)+1);
+ hline1 += tostr(column_of_cell(fcell + i) + 1);
hline1 += '-';
- hline1 += tostr(right_column_of_cell(fcell+i)+1);
+ hline1 += tostr(right_column_of_cell(fcell + i) + 1);
hline1 += "} ";
tmp = 1;
}
}
if (tmp){
file += '\n';
- ret++;
+ ++ret;
}
if (IsLongTable() && (row == endfoot)) {
file += "\\endfoot\n";
- ret++;
+ ++ret;
print_hline = false; // no double line below footer
}
if (IsLongTable() && (row == endlastfoot)) {
file += "\\endlastfoot\n";
- ret++;
+ ++ret;
print_hline = false; // no double line below footer
}
if (IsLongTable() && row_info[row].newpage) {
file += "\\newpage\n";
- ret++;
+ ++ret;
print_hline = false; // no line below a \\newpage-command
}
tmp = 0;
- if (nvcell < numberofcells && (cell < GetNumberOfCells()-1) &&
+ if (nvcell < numberofcells && (cell < GetNumberOfCells() - 1) &&
!ShouldBeVeryLastCell(cell)) {
fcell = nvcell;
- for (i = 0; i < NumberOfCellsInRow(fcell); i++){
- if (TopLine(fcell+i))
- tmp++;
+ for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
+ if (TopLine(fcell + i))
+ ++tmp;
}
- if (tmp == NumberOfCellsInRow(fcell)){
+ if (tmp == NumberOfCellsInRow(fcell)) {
if (print_hline)
file += "\\hline ";
hline2 = "\\hline ";
- }
- else {
+ } else {
tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); i++){
- if (TopLine(fcell+i)){
+ for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
+ if (TopLine(fcell + i)) {
if (print_hline) {
file += "\\cline{";
file += tostr(column_of_cell(fcell+i)+1);
}
if (tmp && print_hline){
file += '\n';
- ret++;
+ ++ret;
}
}
// the order here is important as if one defines two
// lastfooter is NOT displayed!!!
bool sflag2 = (row == endhead) || (row == endfirsthead) ||
(row == endfoot) || (row == endlastfoot);
- row--;
+ --row;
// sflag2 = IsLongTable() && (row >= 0) &&
// (sflag2 || (row == endhead) || (row == endfirsthead));
row += 2;
bool sflag1 = IsLongTable() && (row != endhead) &&
(row != endfirsthead) &&
((row == endfoot) || (row == endlastfoot));
- row--;
+ --row;
if (IsLongTable() && (row == endhead)) {
file += "\\endhead\n";
- ret++;
+ ++ret;
}
if (IsLongTable() && (row == endfirsthead)) {
file += "\\endfirsthead\n";
- ret++;
+ ++ret;
}
if (sflag1) { // add the \hline for next foot row
if (!hline1.empty()) {
file += hline1 + '\n';
- ret++;
+ ++ret;
}
}
// add the \hline for the first row
if (pr_top_hline && sflag2) {
if (!hline2.empty()) {
file += hline2 + '\n';
- ret++;
+ ++ret;
}
}
if (nvcell < numberofcells && RotateCell(nvcell)) {
file += "\\begin{sideways}\n";
- ret++;
+ ++ret;
}
} else {
file += "&\n";
- ret++;
+ ++ret;
if (nvcell < numberofcells && RotateCell(nvcell)) {
file += "\\begin{sideways}\n";
- ret++;
+ ++ret;
}
}
}
// returns the number of printed newlines
int LyXTable::RoffEndOfCell(ostream & os, int cell)
{
- int i, j;
int ret = 0;
if (cell == GetNumberOfCells() - 1){
++ret;
}
os << "\n";
- ret++;
+ ++ret;
if (row_info[row_of_cell(cell)].bottom_line) {
os << "_\n";
++ret;
}
os << ".TE\n.pl 1c";
} else {
- if (cell < 0){
+ if (cell < 0) {
int fcell = 0;
// preamble
os << "\n.pl 500c\n.TS\n";
- for (j = 0; j<rows; ++j) {
- for (i = 0; i<columns; ++i, ++fcell) {
+ for (int j = 0; j < rows; ++j) {
+ for (int i = 0; i < columns; ++i, ++fcell) {
if (column_info[i].left_line)
os << " | ";
if (cell_info[j][i].multicolumn == CELL_PART_OF_MULTICOLUMN)
file += tostr(columns);
file += "' COLSEP='1' ROWSEP='1'>";
addNewlineAndDepth(file,++depth);
- ret++;
+ ++ret;
for (i = 0; i < columns; ++i) {
file += "<COLSPEC ALIGN='";
file += getDocBookAlign(i, true);
}
file += "'>";
addNewlineAndDepth(file, depth);
- ret++;
+ ++ret;
#ifdef NOT_HANDLED_YET_AS_I_DONT_KNOW_HOW
if (column_info[i].left_line)
file += '|';
cellinfo_of_cell(fvcell)->alignment = column_info[column_of_cell(fvcell)].alignment;
cellinfo_of_cell(fvcell)->top_line = row_info[row_of_cell(fvcell)].top_line;
cellinfo_of_cell(fvcell)->bottom_line = row_info[row_of_cell(fvcell)].bottom_line;
- for (number--;number>0;number--){
+ for (number--; number > 0; --number) {
cellinfo_of_cell(fvcell+number)->multicolumn =
LyXTable::CELL_PART_OF_MULTICOLUMN;
new_width += cellinfo_of_cell(fvcell+number)->width_of_cell;
int row = row_of_cell(cell);
int column = column_of_cell(cell);
int result = 1;
- column++;
+ ++column;
while (column < columns && cell_info[row][column].multicolumn
== LyXTable::CELL_PART_OF_MULTICOLUMN){
- result++;
- column++;
+ ++result;
+ ++column;
}
return result;
}
if (cell_info[row][column].multicolumn
== LyXTable::CELL_BEGIN_OF_MULTICOLUMN){
cell_info[row][column].multicolumn = LyXTable::CELL_NORMAL;
- column++;
+ ++column;
while (column < columns &&
cell_info[row][column].multicolumn
== LyXTable::CELL_PART_OF_MULTICOLUMN){
cell_info[row][column].multicolumn =
LyXTable::CELL_NORMAL;
- column++;
- result++;
+ ++column;
+ ++result;
}
}
set_row_column_number_info();
void LyXTable::delete_column(int column)
{
int i, j;
- columnstruct *column_info2 = new columnstruct[columns-1];
+ columnstruct * column_info2 = new columnstruct[columns-1];
- for (i = 0; i<column; i++){
+ for (i = 0; i < column; ++i) {
column_info2[i] = column_info[i];
}
- for (i = column; i<columns-1; i++){
- column_info2[i] = column_info[i+1];
+ for (i = column; i < columns - 1; ++i) {
+ column_info2[i] = column_info[i + 1];
}
delete[] column_info;
column_info = column_info2;
- for (i = 0; i<rows;i++){
- cellstruct* tmp = cell_info[i];
- cell_info[i] = new cellstruct[columns-1];
- for (j = 0; j<column; j++){
+ for (i = 0; i < rows; ++i) {
+ cellstruct * tmp = cell_info[i];
+ cell_info[i] = new cellstruct[columns - 1];
+ for (j = 0; j < column; ++j) {
cell_info[i][j] = tmp[j];
}
- for (j = column; j<columns-1; j++){
- cell_info[i][j] = tmp[j+1];
+ for (j = column; j < columns - 1; ++j) {
+ cell_info[i][j] = tmp[j + 1];
}
delete[] tmp;
}
- columns--;
+ --columns;
Reinit();
}
+
void LyXTable::SetLongTable(int what)
{
is_long_table = what;
}
+
bool LyXTable::IsLongTable()
{
return is_long_table;
{
if (rotate)
return true;
- for (int i = 0; i<rows;i++){
- for (int j = 0;j<columns;j++){
+ for (int i = 0; i < rows; ++i) {
+ for (int j = 0; j < columns; ++j) {
if (cell_info[i][j].rotate)
return true;
}
return cell;
int row = row_of_cell(cell);
int column = column_of_cell(cell);
- for(;(row>0) && IsContRow(cell_info[row][column].cellno); row--)
+ for(; (row > 0) && IsContRow(cell_info[row][column].cellno); --row)
;
return cell_info[row][column].cellno;
}
if (!IsContRow(fcell))
return false;
while((fcell < GetNumberOfCells() - 1) && IsContRow(fcell))
- fcell++;
+ ++fcell;
if (fcell < GetNumberOfCells() - 1)
return false;
return true;
{
if (CellHasContRow(cell)>= 0)
return false;
- int row = row_of_cell(cell)+1;
+ int row = row_of_cell(cell) + 1;
int column = column_of_cell(cell);
while((row < rows) && IsContRow(cell_info[row][column].cellno))
- row++;
+ ++row;
if (row < rows)
return false; // found another valid row
// I do not have any valid row after the actual
// -*- C++ -*-
-#ifndef _TEX_ACCENT_
-#define _TEX_ACCENT_
+#ifndef TEX_ACCENT
+#define TEX_ACCENT
#include "commandtags.h"
scr.drawLine(gc_foot, offset + row->baseline,
int(tmpx), int(x - tmpx));
- pos++;
+ ++pos;
return;
} else if (c == LyXParagraph::META_INSET) {
Inset * tmpinset = row->par->GetInset(pos);
LyXParagraph::size_type tmp_pos = 0;
while (tmp_pos < pos) {
if (par->IsNewline(tmp_pos))
- cell++;
- tmp_pos++;
+ ++cell;
+ ++tmp_pos;
}
return cell;
}
int w = 0;
while (pos < par->Last() && !par->IsNewline(pos)) {
w += SingleWidth(par, pos);
- pos++;
+ ++pos;
}
if (par->IsNewline(pos))
- pos++;
+ ++pos;
return w;
}
if (pos < last-1) {
last_separator = i;
if (IsLineSeparatorChar(par->GetChar(i+1)))
- last_separator++;
+ ++last_separator;
} else
last_separator = last; // to avoid extra rows
} else
labeladdon = 0;
// Check if any insets are larger
- for (pos = row_ptr->pos; pos <= pos_end; pos++) {
+ for (pos = row_ptr->pos; pos <= pos_end; ++pos) {
if (row_ptr->par->GetChar(pos) == LyXParagraph::META_INSET) {
tmpfont = GetFont(row_ptr->par, pos);
tmpinset = row_ptr->par->GetInset(pos);
// Check if any custom fonts are larger (Asger)
// This is not completely correct, but we can live with the small,
// cosmetic error for now.
- LyXFont::FONT_SIZE maxsize = row_ptr->par->HighestFontInRange(row_ptr->pos, pos_end);
+ LyXFont::FONT_SIZE maxsize = row_ptr->par->HighestFontInRange(row_ptr->pos,
+ pos_end);
if (maxsize > font.size()) {
font.setSize(maxsize);
/* table stuff -- end*/
// This is nicer with box insets:
- maxasc++;
- maxdesc++;
+ ++maxasc;
+ ++maxdesc;
row_ptr->ascent_of_text = maxasc;
// Insert the new row
if (z < lastposition) {
- z++;
+ ++z;
InsertRow(row, row->par, z);
row = row->next;
row->height = 0;
} else {
row = row->next;
- z++;
+ ++z;
if (row->pos == z)
not_ready = false; // the rest will not change
else {
if (z < row->par->Last() ) {
if (!row->next || (row->next && row->next->par != row->par)) {
/* insert a new row */
- z++;
+ ++z;
InsertRow(row, row->par, z);
row = row->next;
row->height = 0;
}
else {
row= row->next;
- z++;
+ ++z;
if (row->pos != z)
row->pos = z;
}
/* ok, move the cursor right before the footnote */
/* just a little faster than using CursorRight() */
- for (cursor.pos= 0; cursor.par->ParFromPos(cursor.pos)!= par; cursor.pos++);
+ for (cursor.pos = 0;
+ cursor.par->ParFromPos(cursor.pos) != par; cursor.pos++);
/* now the cursor is at the beginning of the physical par */
SetCursor(cursor.par,
cursor.pos + cursor.par->ParFromPos(cursor.pos)->text.size());
!cursor.par->table->IsContRow(cell)) {
while (pos < cursor.par->Last() &&
!cursor.par->IsNewline(pos))
- pos++;
+ ++pos;
if (pos < cursor.par->Last())
- pos++;
- cell++;
+ ++pos;
+ ++cell;
}
while((pos < cursor.par->Last()) &&
cursor.par->table->IsContRow(cell)) {
while (pos < cursor.par->Last() &&
!cursor.par->IsNewline(pos))
- pos++;
+ ++pos;
if (pos < cursor.par->Last())
- pos++;
- cell++;
+ ++pos;
+ ++cell;
}
cell_org = --cell;
if (pos < cursor.par->Last())
- pos--;
+ --pos;
}
while (pos < cursor.par->Last() &&
(cell == cell_org || !cursor.par->table->IsFirstCell(cell))){
while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos))
- pos++;
+ ++pos;
if (pos < cursor.par->Last())
- pos++;
- cell++;
+ ++pos;
+ ++cell;
}
/* insert the new cells */
(cell == cell_org
|| !cursor.par->table->IsFirstCell(cell))){
while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos))
- pos++;
+ ++pos;
if (pos < cursor.par->Last())
- pos++;
- cell++;
+ ++pos;
+ ++cell;
}
/* insert the new cells */
int number = cursor.par->table->NumberOfCellsInRow(cell_org);
- int i;
- for (i= 0; i<number; i++)
+ for (int i = 0; i < number; ++i)
cursor.par->InsertChar(pos, LyXParagraph::META_NEWLINE);
/* append the row into the table */
if (!selection){
cursor.par->table->SetRightLine(actCell, lineSet);
} else {
- LyXParagraph::size_type i;
int n = -1, m = -2;
- for (i= sel_start_cursor.pos; i<= sel_end_cursor.pos; i++){
+ LyXParagraph::size_type i = sel_start_cursor.pos;
+ for (; i <= sel_end_cursor.pos; ++i) {
if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) {
cursor.par->table->SetRightLine(n, lineSet);
m = n;
if (!selection){
cursor.par->table->SetAlignment(actCell, setAlign);
} else {
- LyXParagraph::size_type i;
int n = -1, m = -2;
- for (i= sel_start_cursor.pos; i<= sel_end_cursor.pos; i++){
+ LyXParagraph::size_type i = sel_start_cursor.pos;
+ for (; i <= sel_end_cursor.pos; ++i) {
if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) {
cursor.par->table->SetAlignment(n, setAlign);
m = n;
int newlines = cursor.par->table->UnsetMultiColumn(actCell);
LyXParagraph::size_type pos = cursor.pos;
while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos))
- pos++;
- for (;newlines;newlines--)
+ ++pos;
+ for (; newlines; --newlines)
cursor.par->InsertChar(pos, LyXParagraph::META_NEWLINE);
RedoParagraph();
return;
sel_start_cursor.par->InsertChar(i, ' ');
else {
sel_end_cursor.pos--;
- i--;
+ --i;
}
- number++;
+ ++number;
}
}
cursor.par->table->
if (!selection){
cursor.par->table->SetRotateCell(actCell, false);
} else {
- LyXParagraph::size_type i;
int n = -1, m = -2;
- for (i= sel_start_cursor.pos; i<= sel_end_cursor.pos; i++){
+ LyXParagraph::size_type i = sel_start_cursor.pos;
+ for (; i <= sel_end_cursor.pos; ++i) {
if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) {
cursor.par->table->SetRotateCell(n, false);
m = n;
LyXParagraph::size_type tmp_pos = pos;
/* update the table information */
while (tmp_pos && !par->IsNewline(tmp_pos - 1))
- tmp_pos--;
+ --tmp_pos;
if (par->table->SetWidthOfCell(NumberOfCell(par, pos),
WidthOfCell(par, tmp_pos))) {
LyXCursor tmpcursor = cursor;
{
// printf("Current pos1 %d", tmpcursor.pos) ;
tmpcursor.pos++;
- steps++;
+ ++steps;
}
// Advance through word.
while ( tmpcursor.pos < tmpcursor.par->Last() &&
{
// printf("Current pos2 %d", tmpcursor.pos) ;
tmpcursor.pos++;
- steps++;
+ ++steps;
}
}
SetCursor(tmpcursor.par, tmpcursor.pos);
LyXCursor old_cursor = cursor;
int old_cur_par_id = old_cursor.par->id();
- int old_cur_par_prev_id = old_cursor.par->previous->id();
+ int old_cur_par_prev_id = old_cursor.par->previous ?
+ old_cursor.par->previous->id() : 0;
// just move to the right
CursorRightIntern();
// old_cursor. Will a solution where we compare paragraph id's
//work better?
#if 1
- if (cursor.par->previous->id() == old_cur_par_prev_id
+ if ((cursor.par->previous ? cursor.par->previous->id() : 0)
+ == old_cur_par_prev_id
&& cursor.par->id() != old_cur_par_id)
return; // delete-empty-paragraph-mechanism has done it
#else
on_off);
x_old = x;
/* take care about the alignment and other spaces */
- cell++;
+ ++cell;
x += row_ptr->par->table->GetBeginningOfTextInCell(cell);
if (row_ptr->par->table->IsFirstCell(cell))
- cell--; // little hack, sorry
- pos++;
+ --cell; // little hack, sorry
+ ++pos;
} else if (row_ptr->par->IsHfill(pos)) {
x += 1;
offset + row_ptr->baseline - DefaultHeight()/2,
offset + row_ptr->baseline);
x += 2;
- pos++;
+ ++pos;
} else {
if (row_ptr->par->IsSeparator(pos)) {
tmpx = x;
int(x - tmpx));
}
}
- pos++;
+ ++pos;
} else
Draw(row_ptr, pos, scr, offset, x);
}
offset + row_ptr->baseline);
}
x += 2;
- pos++;
+ ++pos;
} else {
if (row_ptr->par->IsSeparator(pos)) {
tmpx = x;
int(x - tmpx));
}
}
- pos++;
+ ++pos;
} else
Draw(row_ptr, pos, scr, offset, x);
}
int last = RowLast(row);
if (row->par->IsNewline(last))
- last--;
+ --last;
LyXLayout const & layout = textclasslist.Style(parameters->textclass,
row->par->GetLayout());
if (x_old + row->par->table->WidthOfColumn(cell) <= x){
tmpx = x_old + row->par->table->WidthOfColumn(cell);
x_old = tmpx;
- cell++;
+ ++cell;
tmpx += row->par->table->GetBeginningOfTextInCell(cell);
++c;
} else
&& row->par->IsSeparator(c)) {
tmpx+= fill_separator;
}
- c++;
+ ++c;
if (c == main_body
&& row->par->IsLineSeparator(c - 1)) {
tmpx += GetFont(row->par, -2)
if (row == lastrow)
lastrow = tmprow;
- number_of_rows++; // one more row
+ ++number_of_rows; // one more row
}
par->Previous()->GetLayout()
).labeltype != LABEL_BIBLIO
&& layout.labeltype == LABEL_BIBLIO)) {
- for (int i = 0; i<10; i++) {
+ for (int i = 0; i < 10; ++i) {
par->setCounter(i, par->Previous()->GetFirstCounter(i));
}
par->appendix = par->Previous()->FirstPhysicalPar()->appendix;
if (!par->appendix && par->start_of_appendix){
par->appendix = true;
- for (int i = 0; i<10; i++) {
+ for (int i = 0; i < 10; ++i) {
par->setCounter(i, 0);
}
}
par->itemdepth = par->Previous()->FirstPhysicalPar()->itemdepth;
}
else {
- for (int i = 0; i<10; i++) {
+ for (int i = 0; i < 10; ++i) {
par->setCounter(i, 0);
}
par->appendix = par->start_of_appendix;
/* reset the counters.
* A depth change is like a breaking layout
*/
- for (int i = 6 + par->enumdepth + 1; i<10;i++)
+ for (int i = 6 + par->enumdepth + 1; i < 10; ++i)
par->setCounter(i, 0);
}
par->layout = lay;
if (name != textclasslist.NameOfLayout(class2, par->layout)) {
- ret++;
+ ++ret;
string s = "Layout had to be changed from\n"
+ name + " to " + textclasslist.NameOfLayout(class2, par->layout)
+ "\nbecause of class conversion from\n"
int cell = NumberOfCell(row->par, row->pos);
float x_old = x;
x += row->par->table->GetBeginningOfTextInCell(cell);
- for (pos = row->pos; pos < cursor.pos; pos++) {
+ for (pos = row->pos; pos < cursor.pos; ++pos) {
if (row->par->IsNewline(pos)) {
x = x_old + row->par->table->WidthOfColumn(cell);
x_old = x;
- cell++;
+ ++cell;
x += row->par->table->GetBeginningOfTextInCell(cell);
} else {
x += SingleWidth(row->par, pos);
} else
/* table stuff -- end*/
- for (pos = row->pos; pos < cursor.pos; pos++) {
+ for (pos = row->pos; pos < cursor.pos; ++pos) {
if (pos && pos == main_body
&& !row->par->IsLineSeparator(pos - 1)) {
x += GetFont(row->par, -2).stringWidth(
* ======================================================
*
* LyX, The Document Processor
- * Copyright (C) 1995 Matthias Ettrich
+ * Copyright 1995 Matthias Ettrich
*
- * This file is Copyright (C) 1996-1999
+ * This file is Copyright 1996-1999
* Lars Gullik Bjønnes
*
* ====================================================== */
projects / features.git / commitdiff