further code uglification to make Jean-Marc's compiler happy

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

diff --git a/src/mathed/formula.C b/src/mathed/formula.C
index ca63b9210fe7e48a65424c1a2482f3f94eac5d72..b99d255eb971d075756d03cf9a910ba41929f9c7 100644 (file)
--- a/src/mathed/formula.C
+++ b/src/mathed/formula.C
@@ -188,7 +188,7 @@ InsetFormula::localDispatch(BufferView * bv, kb_action action,
                        if (display()) {
                                bv->lockedInsetStoreUndo(Undo::INSERT);
                                bool old = par_->numberedType();
-                               for (int row = 0; row < par_->nrows(); ++row)
+                               for (unsigned int row = 0; row < par_->nrows(); ++row)
                                        par_->numbered(row, !old);
                                bv->owner()->message(old ? _("No number") : _("Number"));
                                updateLocal(bv, true);

diff --git a/src/mathed/formulabase.C b/src/mathed/formulabase.C
index a9b75d324d85f00ef5a2c82d363cff917e0a0e25..4b963fb02e4bac1404e59faa54b0f82733ebddf0 100644 (file)
--- a/src/mathed/formulabase.C
+++ b/src/mathed/formulabase.C
@@ -91,7 +91,7 @@ bool openNewInset(BufferView * bv, UpdatableInset * new_inset)
 
 
 // returns the nearest enclosing grid
-MathArrayInset * matrixpar(int & idx)
+MathArrayInset * matrixpar(unsigned int & idx)
 {
        idx = 0;
        return (mathcursor ? mathcursor->enclosingArray(idx) : 0); 
@@ -555,7 +555,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action,
        {
                bv->lockedInsetStoreUndo(Undo::INSERT);
                lyxerr << "handling halign '" << arg << "'\n";
-               int idx;
+               unsigned int idx;
                MathArrayInset * p = matrixpar(idx);
                if (!p)
                        break; 
@@ -568,7 +568,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action,
        {
                bv->lockedInsetStoreUndo(Undo::INSERT);
                lyxerr << "handling valign '" << arg << "'\n";
-               int idx;
+               unsigned int idx;
                MathArrayInset * p = matrixpar(idx);
                if (!p)
                        break; 
@@ -580,7 +580,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action,
        case LFUN_MATH_ROW_INSERT:
        {
                bv->lockedInsetStoreUndo(Undo::INSERT);
-               int idx;
+               unsigned int idx;
                MathArrayInset * p = matrixpar(idx);
                lyxerr << " calling LFUN_MATH_ROW_INSERT on " << p << endl;
                if (!p)
@@ -593,7 +593,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action,
        case LFUN_MATH_ROW_DELETE:
        {
                bv->lockedInsetStoreUndo(Undo::INSERT);
-               int idx;
+               unsigned int idx;
                MathArrayInset * p = matrixpar(idx);
                lyxerr << " calling LFUN_MATH_ROW_DELETE on " << p << endl;
                if (!p)
@@ -606,7 +606,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action,
        case LFUN_MATH_COLUMN_INSERT:
        {
                bv->lockedInsetStoreUndo(Undo::INSERT);
-               int idx;
+               unsigned int idx;
                MathArrayInset * p = matrixpar(idx);
                if (!p)
                        break; 
@@ -618,7 +618,7 @@ InsetFormulaBase::localDispatch(BufferView * bv, kb_action action,
        case LFUN_MATH_COLUMN_DELETE:
        {
                bv->lockedInsetStoreUndo(Undo::INSERT);
-               int idx;
+               unsigned int idx;
                MathArrayInset * p = matrixpar(idx);
                if (!p)
                        break; 

diff --git a/src/mathed/math_arrayinset.C b/src/mathed/math_arrayinset.C
index 65675351215179f0d2af72e6e79494b5bcae8224..8e49f00026bf3dabfa2debaeca619fa944f7e68f 100644 (file)
--- a/src/mathed/math_arrayinset.C
+++ b/src/mathed/math_arrayinset.C
@@ -27,7 +27,7 @@ void MathArrayInset::write(std::ostream & os, bool fragile) const
                os << '[' << char(v_align_) << ']';
 
        os << '{';
-       for (int col = 0; col < ncols(); ++col)
+       for (unsigned int col = 0; col < ncols(); ++col)
                os << colinfo_[col].align_;
        os << "}\n";
 

diff --git a/src/mathed/math_cursor.C b/src/mathed/math_cursor.C
index b30a0f00d62c1311bf9b3b3f8cf81a7378e6e12f..92843e5349b98773a4ba3ee74d046dda84632ba2 100644 (file)
--- a/src/mathed/math_cursor.C
+++ b/src/mathed/math_cursor.C
@@ -40,13 +40,14 @@
 #include "math_specialcharinset.h"
 #include "math_parser.h"
 
+#define FILEDEBUG 0
+
 using std::endl;
 using std::min;
 using std::max;
 using std::swap;
 using std::isalnum;
 
-
 namespace {
 
 struct Selection
@@ -60,7 +61,7 @@ struct Selection
                if (i1.idx_ == i2.idx_)
                        data_.push_back(MathArray(i1.cell(), i1.pos_, i2.pos_));
                else {
-                       std::vector<int> indices = i1.par_->idxBetween(i1.idx_, i2.idx_);
+                       std::vector<unsigned int> indices = i1.par_->idxBetween(i1.idx_, i2.idx_);
                        for (unsigned i = 0; i < indices.size(); ++i)
                                data_.push_back(i1.cell(indices[i]));
                }
@@ -74,7 +75,7 @@ struct Selection
                if (i1.idx_ == i2.idx_)
                        i1.cell().erase(i1.pos_, i2.pos_);
                else {
-                       std::vector<int> indices = i1.par_->idxBetween(i1.idx_, i2.idx_);
+                       std::vector<unsigned int> indices = i1.par_->idxBetween(i1.idx_, i2.idx_);
                        for (unsigned i = 0; i < indices.size(); ++i)
                                i1.cell(indices[i]).erase();
                }
@@ -107,12 +108,14 @@ struct Selection
 Selection theSelection;
 
 
+#if FILEDEBUG
 std::ostream & operator<<(std::ostream & os, MathCursorPos const & p)
 {
        os << "(par: " << p.par_ << " idx: " << p.idx_
           << " pos: " << p.pos_ << ")";
        return os;
 }
+#endif
 
 }
 
@@ -176,9 +179,9 @@ MathInset * MathCursor::parInset(int i) const
 }
 
 
+#if FILEDEBUG
 void MathCursor::dump(char const *) const
 {
-#if 0
        lyxerr << "MC: " << what << "\n";
        for (unsigned i = 0; i < Cursor_.size(); ++i)
                lyxerr << "  i: " << i 
@@ -186,15 +189,12 @@ void MathCursor::dump(char const *) const
                        << " idx: " << Cursor_[i].idx_
                        << " par: " << Cursor_[i].par_ << "\n";
        //lyxerr        << " sel: " << selection_ << " data: " << array() << "\n";
-#endif
 }
 
-
 void MathCursor::seldump(char const * str) const
 {
        //lyxerr << "SEL: " << str << ": '" << theSelection << "'\n";
        //dump("   Pos");
-       return;
 
        lyxerr << "\n\n\n=================vvvvvvvvvvvvv=======================   "
                <<  str << "\ntheSelection: " << selection_
@@ -209,6 +209,13 @@ void MathCursor::seldump(char const * str) const
        lyxerr << "\n===================^^^^^^^^^^^^=====================\n\n\n";
 }
 
+#else
+
+void MathCursor::seldump(char const *) const {}
+void MathCursor::dump(char const *) const {}
+
+#endif
+
 
 bool MathCursor::isInside(MathInset const * p) const
 {
@@ -355,11 +362,11 @@ void MathCursor::setPos(int x, int y)
        cursor().par_  = outerPar();
 
        while (1) {
-               idx() = -1;
-               cursor().pos_ = -1;
+               idx() = 0;
+               cursor().pos_ = 0;
                //lyxerr << "found idx: " << idx() << " cursor: " << pos()  << "\n";
                int distmin = 1 << 30; // large enough
-               for (int i = 0; i < par()->nargs(); ++i) {
+               for (unsigned int i = 0; i < par()->nargs(); ++i) {
                        MathXArray const & ar = par()->xcell(i);
                        int x1 = x - ar.xo();
                        int y1 = y - ar.yo();
@@ -745,7 +752,7 @@ void MathCursor::drawSelection(Painter & pain) const
                int y2 = c.yo() + c.descent();
                pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::selection);
        } else {
-               std::vector<int> indices = i1.par_->idxBetween(i1.idx_, i2.idx_);
+               std::vector<unsigned int> indices = i1.par_->idxBetween(i1.idx_, i2.idx_);
                for (unsigned i = 0; i < indices.size(); ++i) {
                        MathXArray & c = i1.xcell(indices[i]);
                        int x1 = c.xo();
@@ -774,7 +781,7 @@ void MathCursor::handleFont(MathTextCodes t)
                getSelection(i1, i2); 
                if (i1.idx_ == i2.idx_) {
                        MathArray & ar = i1.cell();
-                       for (int pos = i1.pos_; pos != i2.pos_; ++pos) {
+                       for (unsigned int pos = i1.pos_; pos != i2.pos_; ++pos) {
                                MathInset * p = ar.at(pos)->nucleus();
                                if (p)
                                        p->handleFont(t);
@@ -825,25 +832,25 @@ InsetFormulaBase const * MathCursor::formula()
 }
 
 
-int MathCursor::idx() const
+unsigned int MathCursor::idx() const
 {
        return cursor().idx_;
 }
 
 
-int & MathCursor::idx()
+unsigned int & MathCursor::idx()
 {
        return cursor().idx_;
 }
 
 
-int MathCursor::pos() const
+unsigned int MathCursor::pos() const
 {
        return cursor().pos_;
 }
 
 
-int & MathCursor::pos()
+unsigned int & MathCursor::pos()
 {
        return cursor().pos_;
 }
@@ -861,7 +868,7 @@ bool MathCursor::selection() const
 }
 
 
-MathArrayInset * MathCursor::enclosingArray(int & idx) const
+MathArrayInset * MathCursor::enclosingArray(unsigned int & idx) const
 {
        for (int i = Cursor_.size() - 1; i >= 0; --i) {
                if (Cursor_[i].par_->isArray()) {
@@ -900,41 +907,35 @@ void MathCursor::normalize() const
 #endif
        MathCursor * it = const_cast<MathCursor *>(this);
 
-       if (idx() < 0)
-               lyxerr << "this should not really happen - 1: " << idx() << "\n";
        if (idx() >= par()->nargs()) {
-               lyxerr << "this should not really happen - 2: "
+               lyxerr << "this should not really happen - 1: "
                       << idx() << " " << par()->nargs() << "\n";
                dump("error 2");
        }
-       it->idx()    = max(idx(), 0);
        it->idx()    = min(idx(), par()->nargs() - 1);
 
-       if (pos() < 0)
-               lyxerr << "this should not really happen - 3: " << pos() << "\n";
        if (pos() > size()) {
-               lyxerr << "this should not really happen - 4: "
+               lyxerr << "this should not really happen - 2: "
                       << pos() << " " << size() << "\n";
                dump("error 4");
        }
-       it->pos() = max(pos(), 0);
        it->pos() = min(pos(), size());
 }
 
 
-int MathCursor::size() const
+unsigned int MathCursor::size() const
 {
        return array().size();
 }
 
 
-int MathCursor::col() const
+unsigned int MathCursor::col() const
 {
        return par()->col(idx());
 }
 
 
-int MathCursor::row() const
+unsigned int MathCursor::row() const
 {
        return par()->row(idx());
 }
@@ -1010,7 +1011,7 @@ MathArray & MathCursor::array() const
                return dummy;
        }
 
-       if (idx() < 0 || idx() >= par()->nargs()) {
+       if (idx() >= par()->nargs()) {
                lyxerr << "############  idx_ " << idx() << " not valid\n";
                return dummy;
        }
@@ -1065,10 +1066,10 @@ void MathCursor::breakLine()
                p->addRow(row());
 
                // split line
-               const int r = row();
-               for (int c = col() + 1; c < p->ncols(); ++c) {
-                       const int i1 = p->index(r, c);
-                       const int i2 = p->index(r + 1, c);      
+               const unsigned int r = row();
+               for (unsigned int c = col() + 1; c < p->ncols(); ++c) {
+                       const unsigned int i1 = p->index(r, c);
+                       const unsigned int i2 = p->index(r + 1, c);     
                        lyxerr << "swapping cells " << i1 << " and " << i2 << "\n";
                        p->cell(i1).swap(p->cell(i2));
                }
@@ -1082,7 +1083,7 @@ void MathCursor::breakLine()
 
 char MathCursor::valign() const
 {
-       int idx;
+       unsigned int idx;
        MathArrayInset * p = enclosingArray(idx);
        return p ? p->valign() : 0;
 }
@@ -1090,7 +1091,7 @@ char MathCursor::valign() const
 
 char MathCursor::halign() const
 {
-       int idx;
+       unsigned int idx;
        MathArrayInset * p = enclosingArray(idx);
        return p ? p->halign(idx % p->ncols()) : 0;
 }
@@ -1121,13 +1122,13 @@ MathCursorPos const & MathCursor::cursor() const
 }
 
 
-int MathCursor::cellXOffset() const
+unsigned int MathCursor::cellXOffset() const
 {
        return par()->cellXOffset(idx());
 }
 
 
-int MathCursor::cellYOffset() const
+unsigned int MathCursor::cellYOffset() const
 {
        return par()->cellYOffset(idx());
 }
@@ -1248,14 +1249,14 @@ void MathCursor::interpret(string const & s)
        //lyxerr << "trans: '" << c << "'  int: " << int(c) << endl;
 
        if (s.size() > 7 && s.substr(0, 7) == "matrix ") {
-               int m = 1;
-               int n = 1;
+               unsigned int m = 1;
+               unsigned int n = 1;
                string v_align;
                string h_align;
                istringstream is(s.substr(7).c_str());
                is >> m >> n >> v_align >> h_align;
-               m = std::max(1, m);
-               n = std::max(1, n);
+               m = std::max(1u, m);
+               n = std::max(1u, n);
                v_align += 'c';
                MathArrayInset * p = new MathArrayInset(m, n);
                p->valign(v_align[0]);
@@ -1423,7 +1424,7 @@ bool operator<(MathCursorPos const & ti, MathCursorPos const & it)
 }
 
 
-MathArray & MathCursorPos::cell(int idx) const
+MathArray & MathCursorPos::cell(unsigned int idx) const
 {
        return par_->cell(idx);
 }
@@ -1435,7 +1436,7 @@ MathArray & MathCursorPos::cell() const
 }
 
 
-MathXArray & MathCursorPos::xcell(int idx) const
+MathXArray & MathCursorPos::xcell(unsigned int idx) const
 {
        return par_->xcell(idx);
 }

diff --git a/src/mathed/math_cursor.h b/src/mathed/math_cursor.h
index 09b98ec2fd1d0271e984b927bbaa08f44f8bfaf6..978da16e401f66b4d4c0e481632dcf460d4e5b09 100644 (file)
--- a/src/mathed/math_cursor.h
+++ b/src/mathed/math_cursor.h
@@ -41,17 +41,17 @@ struct MathCursorPos {
        /// inset
        MathInset * par_;
        /// cell index
-       int idx_;
+       unsigned int idx_;
        /// cell position
-       int pos_;
+       unsigned int pos_;
        /// returns cell corresponding to this position
        MathArray & cell() const;
        /// returns cell corresponding to this position
-       MathArray & cell(int idx) const;
+       MathArray & cell(unsigned int idx) const;
        /// returns xcell corresponding to this position
        MathXArray & xcell() const;
        /// returns xcell corresponding to this position
-       MathXArray & xcell(int idx) const;
+       MathXArray & xcell(unsigned int idx) const;
 };
 
 /// 
@@ -120,15 +120,15 @@ public:
        ///
        MathInset * par() const;
        /// return the next enclosing grid inset and the cursor's index in it
-       MathArrayInset * enclosingArray(int &) const;
+       MathArrayInset * enclosingArray(unsigned int &) const;
        ///
        InsetFormulaBase const * formula();
        ///
-       int pos() const;
+       unsigned int pos() const;
        ///
-       int idx() const;
+       unsigned int idx() const;
        ///
-       int size() const;
+       unsigned int size() const;
        ///
        void interpret(string const &);
        ///
@@ -183,9 +183,9 @@ public:
        ///
        char halign() const;
        ///
-       int col() const;
+       unsigned int col() const;
        ///
-       int row() const;
+       unsigned int row() const;
 
        ///
        MathStyles style() const;
@@ -231,7 +231,7 @@ public:
 
 
        ///  
-       int last() const;
+       unsigned int last() const;
        ///
        MathInset * parInset(int i) const;
        ///
@@ -261,13 +261,13 @@ private:
        /// can the setPos routine enter that inset?
        MathInset * positionable(MathAtom *, int x, int y) const;
        /// write access to cursor cell position
-       int & pos();
+       unsigned int & pos();
        /// write access to cursor cell index
-       int & idx();
+       unsigned int & idx();
        /// x-offset of current cell relative to par xo
-       int cellXOffset() const;
+       unsigned int cellXOffset() const;
        /// y-offset of current cell relative to par yo
-       int cellYOffset() const;
+       unsigned int cellYOffset() const;
        /// current x position relative to par xo
        int xpos() const;
        /// current y position relative to par yo

diff --git a/src/mathed/math_fracinset.h b/src/mathed/math_fracinset.h
index 5db6f340c7053842a19fe694245be9679db00be6..d60ca9bd08fd5778d42db28beb2f41c5d0b8d591 100644 (file)
--- a/src/mathed/math_fracinset.h
+++ b/src/mathed/math_fracinset.h
@@ -26,9 +26,6 @@ public:
        ///
        void draw(Painter &, int x, int y) const;
 public:
-       ///
-       char const name() const;
-
        ///
        const bool atop_;
 };

diff --git a/src/mathed/math_gridinset.C b/src/mathed/math_gridinset.C
index 658f68477b4352004986f88fc4a42960a994a7a1..8f66538195fca5b52be2ad4278946b9dc8b31b50 100644 (file)
--- a/src/mathed/math_gridinset.C
+++ b/src/mathed/math_gridinset.C
@@ -40,7 +40,7 @@ MathGridInset::ColInfo::ColInfo()
 {}
 
 
-MathGridInset::MathGridInset(int m, int n)
+MathGridInset::MathGridInset(unsigned int m, unsigned int n)
        : MathNestInset(m * n), rowinfo_(n), colinfo_(m), v_align_('c')
 {
        if (m <= 0)
@@ -51,7 +51,7 @@ MathGridInset::MathGridInset(int m, int n)
 }
 
 
-int MathGridInset::index(int row, int col) const
+unsigned int MathGridInset::index(unsigned int row, unsigned int col) const
 {
        return col + ncols() * row;
 }
@@ -59,7 +59,7 @@ int MathGridInset::index(int row, int col) const
 
 void MathGridInset::setDefaults()
 {
-       for (int col = 0; col < ncols(); ++col) {
+       for (unsigned int col = 0; col < ncols(); ++col) {
                colinfo_[col].align_ = defaultColAlign(col);
                colinfo_[col].skip_  = defaultColSpace(col);
        }
@@ -68,21 +68,21 @@ void MathGridInset::setDefaults()
 
 void MathGridInset::halign(string const & hh)
 {
-       int n = hh.size();
+       unsigned int n = hh.size();
        if (n > ncols())
                n = ncols();
-       for (int i = 0; i < n; ++i)
+       for (unsigned int i = 0; i < n; ++i)
                colinfo_[i].align_ = hh[i];
 }
 
 
-void MathGridInset::halign(char h, int col)
+void MathGridInset::halign(char h, unsigned int col)
 {
        colinfo_[col].align_ = h;
 }
 
 
-char MathGridInset::halign(int col) const
+char MathGridInset::halign(unsigned int col) const
 {
        return colinfo_[col].align_;
 }
@@ -102,13 +102,13 @@ char MathGridInset::valign() const
 
 
 
-void MathGridInset::vskip(LyXLength const & skip, int row)
+void MathGridInset::vskip(LyXLength const & skip, unsigned int row)
 {
        rowinfo_[row].skip_ = skip;
 }
 
 
-LyXLength MathGridInset::vskip(int row) const
+LyXLength MathGridInset::vskip(unsigned int row) const
 {
        return rowinfo_[row].skip_;
 }
@@ -121,10 +121,10 @@ void MathGridInset::metrics(MathStyles st) const
        size_ = st;
 
        // adjust vertical structure
-       for (int row = 0; row < nrows(); ++row) {
+       for (unsigned int row = 0; row < nrows(); ++row) {
                int asc  = 0;
                int desc = 0;
-               for (int col = 0; col < ncols(); ++col) {
+               for (unsigned int col = 0; col < ncols(); ++col) {
                        MathXArray const & c = xcell(index(row, col));
                        asc  = std::max(asc,  c.ascent());
                        desc = std::max(desc, c.descent());
@@ -156,15 +156,15 @@ void MathGridInset::metrics(MathStyles st) const
                h = rowinfo_.back().offset_ / 2;
        }
 
-       for (int row = 0; row < nrows(); ++row) {
+       for (unsigned int row = 0; row < nrows(); ++row) {
                rowinfo_[row].offset_ -= h;
                rowinfo_[row].offset_ += MATH_BORDER;
        }
        
        // adjust horizontal structure
-       for (int col = 0; col < ncols(); ++col) {
+       for (unsigned int col = 0; col < ncols(); ++col) {
                int wid  = 0;
-               for (int row = 0; row < nrows(); ++row) 
+               for (unsigned int row = 0; row < nrows(); ++row) 
                        wid = std::max(wid, xcell(index(row, col)).width());
                colinfo_[col].width_  = wid;
                colinfo_[col].offset_ = colinfo_[col].width_;
@@ -241,15 +241,15 @@ void MathGridInset::draw(Painter & pain, int x, int y) const
 {
        xo(x);
        yo(y);
-       for (int idx = 0; idx < nargs(); ++idx)
+       for (unsigned int idx = 0; idx < nargs(); ++idx)
                xcell(idx).draw(pain, x + cellXOffset(idx), y + cellYOffset(idx));
 }
 
 
 void MathGridInset::write(std::ostream & os, bool fragile) const
 {
-       for (int row = 0; row < nrows(); ++row) {
-               for (int col = 0; col < ncols(); ++col) {
+       for (unsigned int row = 0; row < nrows(); ++row) {
+               for (unsigned int col = 0; col < ncols(); ++col) {
                        cell(index(row, col)).write(os, fragile);
                        os << eocString(col);
                }
@@ -258,9 +258,9 @@ void MathGridInset::write(std::ostream & os, bool fragile) const
 }
 
 
-string MathGridInset::eolString(int row) const
+string MathGridInset::eolString(unsigned int row) const
 {
-       if (row == nrows() - 1) 
+       if (row + 1 == nrows()) 
                return "";
 
        if (rowinfo_[row].skip_.value() != 0)
@@ -275,15 +275,15 @@ string MathGridInset::eolString(int row) const
 }
 
 
-string MathGridInset::eocString(int col) const
+string MathGridInset::eocString(unsigned int col) const
 {
-       if (col == ncols() - 1)
+       if (col + 1 == ncols())
                return "";
        return " & ";
 }
 
 
-void MathGridInset::addRow(int row)
+void MathGridInset::addRow(unsigned int row)
 {
        rowinfo_.insert(rowinfo_.begin() + row + 1, RowInfo());
        cells_.insert(cells_.begin() + (row + 1) * ncols(), ncols(), MathXArray());
@@ -293,12 +293,12 @@ void MathGridInset::addRow(int row)
 void MathGridInset::appendRow()
 {
        rowinfo_.push_back(RowInfo());
-       for (int i = 0; i < ncols(); ++i)
+       for (unsigned int i = 0; i < ncols(); ++i)
                cells_.push_back(cells_type::value_type());
 }
 
 
-void MathGridInset::delRow(int row)
+void MathGridInset::delRow(unsigned int row)
 {
        if (nrows() == 1)
                return;
@@ -310,14 +310,14 @@ void MathGridInset::delRow(int row)
 }
 
 
-void MathGridInset::addCol(int newcol)
+void MathGridInset::addCol(unsigned int newcol)
 {
-       int const nc = ncols();
-       int const nr = nrows();
+       unsigned int const nc = ncols();
+       unsigned int const nr = nrows();
        cells_type new_cells((nc + 1) * nr);
        
-       for (int row = 0; row < nr; ++row)
-               for (int col = 0; col < nc; ++col)
+       for (unsigned int row = 0; row < nr; ++row)
+               for (unsigned int col = 0; col < nc; ++col)
                        new_cells[row * (nc + 1) + col + (col > newcol)]
                                = cells_[row * nc + col];
        std::swap(cells_, new_cells);
@@ -329,13 +329,13 @@ void MathGridInset::addCol(int newcol)
 }
 
 
-void MathGridInset::delCol(int col)
+void MathGridInset::delCol(unsigned int col)
 {
        if (ncols() == 1)
                return;
 
        cells_type tmpcells;
-       for (int i = 0; i < nargs(); ++i) 
+       for (unsigned int i = 0; i < nargs(); ++i) 
                if (i % ncols() != col)
                        tmpcells.push_back(cells_[i]);
        std::swap(cells_, tmpcells);
@@ -344,9 +344,9 @@ void MathGridInset::delCol(int col)
 }
 
 
-int MathGridInset::cellXOffset(int idx) const
+int MathGridInset::cellXOffset(unsigned int idx) const
 {
-       int c = col(idx);
+       unsigned int c = col(idx);
        int x = colinfo_[c].offset_;
        char align = colinfo_[c].align_;
        if (align == 'r' || align == 'R')
@@ -357,13 +357,13 @@ int MathGridInset::cellXOffset(int idx) const
 }
 
 
-int MathGridInset::cellYOffset(int idx) const
+int MathGridInset::cellYOffset(unsigned int idx) const
 {
        return rowinfo_[row(idx)].offset_;
 }
 
 
-bool MathGridInset::idxUp(int & idx, int & pos) const
+bool MathGridInset::idxUp(unsigned int & idx, unsigned int & pos) const
 {
        if (idx < ncols())
                return false;
@@ -373,7 +373,7 @@ bool MathGridInset::idxUp(int & idx, int & pos) const
 }
 
        
-bool MathGridInset::idxDown(int & idx, int & pos) const
+bool MathGridInset::idxDown(unsigned int & idx, unsigned int & pos) const
 {
        if (idx >= ncols() * (nrows() - 1))
                return false;
@@ -383,7 +383,7 @@ bool MathGridInset::idxDown(int & idx, int & pos) const
 }
        
        
-bool MathGridInset::idxLeft(int & idx, int & pos) const
+bool MathGridInset::idxLeft(unsigned int & idx, unsigned int & pos) const
 {
        // leave matrix if on the left hand edge
        if (col(idx) == 0)
@@ -394,7 +394,7 @@ bool MathGridInset::idxLeft(int & idx, int & pos) const
 }
        
        
-bool MathGridInset::idxRight(int & idx, int & pos) const
+bool MathGridInset::idxRight(unsigned int & idx, unsigned int & pos) const
 {
        // leave matrix if on the right hand edge
        if (col(idx) == ncols() - 1)
@@ -405,7 +405,7 @@ bool MathGridInset::idxRight(int & idx, int & pos) const
 }
 
 
-bool MathGridInset::idxFirst(int & idx, int & pos) const
+bool MathGridInset::idxFirst(unsigned int & idx, unsigned int & pos) const
 {
        switch (v_align_) {
                case 't':
@@ -422,7 +422,7 @@ bool MathGridInset::idxFirst(int & idx, int & pos) const
 }
 
 
-bool MathGridInset::idxLast(int & idx, int & pos) const
+bool MathGridInset::idxLast(unsigned int & idx, unsigned int & pos) const
 {
        switch (v_align_) {
                case 't':
@@ -439,7 +439,7 @@ bool MathGridInset::idxLast(int & idx, int & pos) const
 }
 
 
-void MathGridInset::idxDelete(int & idx, bool & popit, bool & deleteit)
+void MathGridInset::idxDelete(unsigned int & idx, bool & popit, bool & deleteit)
 {
        popit    = false;
        deleteit = false;
@@ -447,7 +447,7 @@ void MathGridInset::idxDelete(int & idx, bool & popit, bool & deleteit)
        // delete entire row if in first cell of empty row
        if (col(idx) == 0 && nrows() > 1) {
                bool deleterow = true;
-               for (int i = idx; i < idx + ncols(); ++i)
+               for (unsigned int i = idx; i < idx + ncols(); ++i)
                        if (cell(i).size()) {
                                deleterow = false;
                                break;
@@ -466,7 +466,7 @@ void MathGridInset::idxDelete(int & idx, bool & popit, bool & deleteit)
 }
 
 
-void MathGridInset::idxDeleteRange(int /*from*/, int /*to*/)
+void MathGridInset::idxDeleteRange(unsigned int /*from*/, unsigned int /*to*/)
 {
 // leave this unimplemented unless someone wants to have it.
 /*
@@ -482,27 +482,28 @@ void MathGridInset::idxDeleteRange(int /*from*/, int /*to*/)
 }
 
 
-MathGridInset::RowInfo const & MathGridInset::rowinfo(int i) const
+MathGridInset::RowInfo const & MathGridInset::rowinfo(unsigned int i) const
 {
        return rowinfo_[i];
 }
 
 
-MathGridInset::RowInfo & MathGridInset::rowinfo(int i)
+MathGridInset::RowInfo & MathGridInset::rowinfo(unsigned int i)
 {
        return rowinfo_[i];
 }
 
 
-std::vector<int> MathGridInset::idxBetween(int from, int to) const
+std::vector<unsigned int>
+       MathGridInset::idxBetween(unsigned int from, unsigned int to) const
 {
-       int r1 = std::min(row(from), row(to));
-       int r2 = std::max(row(from), row(to));
-       int c1 = std::min(col(from), col(to));
-       int c2 = std::max(col(from), col(to));
-       std::vector<int> res;
-       for (int i = r1; i <= r2; ++i)
-               for (int j = c1; j <= c2; ++j)
+       unsigned int r1 = std::min(row(from), row(to));
+       unsigned int r2 = std::max(row(from), row(to));
+       unsigned int c1 = std::min(col(from), col(to));
+       unsigned int c2 = std::max(col(from), col(to));
+       std::vector<unsigned int> res;
+       for (unsigned int i = r1; i <= r2; ++i)
+               for (unsigned int j = c1; j <= c2; ++j)
                        res.push_back(index(i, j));
        return res;
 }

diff --git a/src/mathed/math_gridinset.h b/src/mathed/math_gridinset.h
index 25555c1e9182f0abbfdf30d91124a41bcb40f4b9..2bea095771d9df82a58ca7a7f813d99570319937 100644 (file)
--- a/src/mathed/math_gridinset.h
+++ b/src/mathed/math_gridinset.h
@@ -60,7 +60,7 @@ class MathGridInset : public MathNestInset {
 
 public: 
        ///
-       MathGridInset(int m, int n);
+       MathGridInset(unsigned int m, unsigned int n);
        ///
        void write(std::ostream &, bool fragile) const;
        ///
@@ -70,82 +70,82 @@ public:
        ///
        void halign(string const &);
        ///
-       void halign(char c, int col);
+       void halign(char c, unsigned int col);
        ///
-       char halign(int col) const;
+       char halign(unsigned int col) const;
        ///
        void valign(char c);
        ///
        char valign() const;
        ///
-       void vskip(LyXLength const &, int row);
+       void vskip(LyXLength const &, unsigned int row);
        ///
-       LyXLength vskip(int row) const;
+       LyXLength vskip(unsigned int row) const;
        ///
-       void resize(short int type, int cols);
+       void resize(short int type, unsigned int cols);
        ///
-       const RowInfo & rowinfo(int row) const;
+       const RowInfo & rowinfo(unsigned int row) const;
        ///
-       RowInfo & rowinfo(int row);
+       RowInfo & rowinfo(unsigned int row);
        ///
        bool isGrid() const { return true; }
 
        ///
-       int ncols() const { return colinfo_.size(); }
+       unsigned int ncols() const { return colinfo_.size(); }
        ///
-       int nrows() const { return rowinfo_.size(); }
+       unsigned int nrows() const { return rowinfo_.size(); }
        ///
-       int col(int idx) const { return idx % ncols(); }
+       unsigned int col(unsigned int idx) const { return idx % ncols(); }
        ///
-       int row(int idx) const { return idx / ncols(); }
+       unsigned int row(unsigned int idx) const { return idx / ncols(); }
        ///
-       int cellXOffset(int idx) const;
+       int cellXOffset(unsigned int idx) const;
        ///
-       int cellYOffset(int idx) const;
+       int cellYOffset(unsigned int idx) const;
 
        ///
-       bool idxUp(int &, int &) const;
+       bool idxUp(unsigned int &, unsigned int &) const;
        ///
-       bool idxDown(int &, int &) const;
+       bool idxDown(unsigned int &, unsigned int &) const;
        ///
-       bool idxLeft(int &, int &) const;
+       bool idxLeft(unsigned int &, unsigned int &) const;
        ///
-       bool idxRight(int &, int &) const;
+       bool idxRight(unsigned int &, unsigned int &) const;
        ///
-       bool idxFirst(int &, int &) const;
+       bool idxFirst(unsigned int &, unsigned int &) const;
        ///
-       bool idxLast(int &, int &) const;
+       bool idxLast(unsigned int &, unsigned int &) const;
        ///
-       void idxDelete(int &, bool &, bool &);
+       void idxDelete(unsigned int &, bool &, bool &);
        ///
-       void idxDeleteRange(int, int);
+       void idxDeleteRange(unsigned int, unsigned int);
                        
        ///
-       void addRow(int);
+       void addRow(unsigned int);
        ///
-       void delRow(int);
+       void delRow(unsigned int);
        ///
-       void addCol(int);
+       void addCol(unsigned int);
        ///
-       void delCol(int);
+       void delCol(unsigned int);
        ///
        virtual void appendRow();
        ///
-       int index(int row, int col) const;
+       unsigned int index(unsigned int row, unsigned int col) const;
        ///
-       std::vector<int> idxBetween(int from, int to) const;
+       std::vector<unsigned int> idxBetween(unsigned int from, unsigned int to) const;
        ///
-       virtual int defaultColSpace(int) { return 10; }
+       virtual int defaultColSpace(unsigned int) { return 10; }
        ///
-       virtual char defaultColAlign(int) { return 'c'; }
+       virtual char defaultColAlign(unsigned int) { return 'c'; }
        ///
        void setDefaults();
 
 protected:
        /// returns proper 'end of line' code for LaTeX
-       string eolString(int row) const;
+       string eolString(unsigned int row) const;
        /// returns proper 'end of column' code for LaTeX
-       string eocString(int col) const;
+       string eocString(unsigned int col) const;
 
        /// row info
        std::vector<RowInfo> rowinfo_;

diff --git a/src/mathed/math_inset.C b/src/mathed/math_inset.C
index 25f194aed37908d6fe24c823a4062f3c124451e9..2b42db794878ba2963bac7ee6ddddd0ad6f6212d 100644 (file)
--- a/src/mathed/math_inset.C
+++ b/src/mathed/math_inset.C
@@ -85,7 +85,7 @@ void MathInset::yo(int y) const
 }
 
 
-int MathInset::nargs() const
+unsigned int MathInset::nargs() const
 {
        return 0;
 }
@@ -93,28 +93,28 @@ int MathInset::nargs() const
 
 MathXArray dummyCell;
 
-MathXArray & MathInset::xcell(int)
+MathXArray & MathInset::xcell(unsigned int)
 {
        lyxerr << "I don't have a cell\n";
        return dummyCell;
 }
 
 
-MathXArray const & MathInset::xcell(int) const
+MathXArray const & MathInset::xcell(unsigned int) const
 {
        lyxerr << "I don't have a cell\n";
        return dummyCell;
 }
 
 
-MathArray & MathInset::cell(int)
+MathArray & MathInset::cell(unsigned int)
 {
        lyxerr << "I don't have a cell\n";
        return dummyCell.data_;
 }
 
 
-MathArray const & MathInset::cell(int) const
+MathArray const & MathInset::cell(unsigned int) const
 {
        lyxerr << "I don't have a cell\n";
        return dummyCell.data_;
@@ -125,74 +125,74 @@ void MathInset::substitute(MathMacro const &)
 {}
 
 
-bool MathInset::idxNext(int &, int &) const
+bool MathInset::idxNext(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxRight(int &, int &) const
+bool MathInset::idxRight(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxPrev(int &, int &) const
+bool MathInset::idxPrev(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxLeft(int &, int &) const
+bool MathInset::idxLeft(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxUp(int &, int &) const
+bool MathInset::idxUp(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxDown(int &, int &) const
+bool MathInset::idxDown(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxFirst(int &, int &) const
+bool MathInset::idxFirst(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxLast(int &, int &) const
+bool MathInset::idxLast(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxHome(int &, int &) const
+bool MathInset::idxHome(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathInset::idxEnd(int &, int &) const
+bool MathInset::idxEnd(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-void MathInset::idxDelete(int &, bool & popit, bool & deleteit)
+void MathInset::idxDelete(unsigned int &, bool & popit, bool & deleteit)
 {
        popit    = false;
        deleteit = false;
 }
 
 
-void MathInset::idxDeleteRange(int, int)
+void MathInset::idxDeleteRange(unsigned int, unsigned int)
 {}
 
 
@@ -255,10 +255,11 @@ void MathInset::validate(LaTeXFeatures &) const
 {}
 
 
-std::vector<int> MathInset::idxBetween(int from, int to) const
+std::vector<unsigned int>
+       MathInset::idxBetween(unsigned int from, unsigned int to) const
 {
-       std::vector<int> res;
-       for (int i = from; i <= to; ++i)
+       std::vector<unsigned int> res;
+       for (unsigned int i = from; i <= to; ++i)
                res.push_back(i);
        return res;
 }

diff --git a/src/mathed/math_inset.h b/src/mathed/math_inset.h
index f95a3b8716677bff5e72871eef89dc83c1fa7358..a9733845da383fb26a8a84f3b248343cddc3d919 100644 (file)
--- a/src/mathed/math_inset.h
+++ b/src/mathed/math_inset.h
@@ -75,50 +75,51 @@ public:
        virtual MathStyles size() const;
 
        /// Where should we go when we press the up cursor key?
-       virtual bool idxUp(int & idx, int & pos) const;
+       virtual bool idxUp(unsigned int & idx, unsigned int & pos) const;
        /// The down key
-       virtual bool idxDown(int & idx, int & pos) const;
+       virtual bool idxDown(unsigned int & idx, unsigned int & pos) const;
        /// The left key
-       virtual bool idxLeft(int & idx, int & pos) const;
+       virtual bool idxLeft(unsigned int & idx, unsigned int & pos) const;
        /// The right key
-       virtual bool idxRight(int & idx, int & pos) const;
+       virtual bool idxRight(unsigned int & idx, unsigned int & pos) const;
 
        /// Move one physical cell up
-       virtual bool idxNext(int & idx, int & pos) const;
+       virtual bool idxNext(unsigned int & idx, unsigned int & pos) const;
        /// Move one physical cell down
-       virtual bool idxPrev(int & idx, int & pos) const;
+       virtual bool idxPrev(unsigned int & idx, unsigned int & pos) const;
 
        /// Target pos when we enter the inset from the left by pressing "Right"
-       virtual bool idxFirst(int & idx, int & pos) const;
+       virtual bool idxFirst(unsigned int & idx, unsigned int & pos) const;
        /// Target pos when we enter the inset from the right by pressing "Left"
-       virtual bool idxLast(int & idx, int & pos) const;
+       virtual bool idxLast(unsigned int & idx, unsigned int & pos) const;
 
        /// Where should we go if we press home?
-       virtual bool idxHome(int & idx, int & pos) const;
+       virtual bool idxHome(unsigned int & idx, unsigned int & pos) const;
        /// Where should we go if we press end?
-       virtual bool idxEnd(int & idx, int & pos) const;
+       virtual bool idxEnd(unsigned int & idx, unsigned int & pos) const;
 
        /// Delete a cell and move cursor
        // the return value indicates whether the cursor should leave the inset
        // and/or the whole inset should be deleted
-       virtual void idxDelete(int & idx, bool & popit, bool & deleteit);
+       virtual void idxDelete(unsigned int & idx, bool & popit, bool & deleteit);
        // deletes a cell range and moves the cursor 
-       virtual void idxDeleteRange(int from, int to);
+       virtual void idxDeleteRange(unsigned int from, unsigned int to);
        // returns list of cell indices that are "between" from and to for
        // selection purposes
-       virtual std::vector<int> idxBetween(int from, int to) const;
+       virtual std::vector<unsigned int>
+               idxBetween(unsigned int from, unsigned int to) const;
 
        ///
-       virtual int nargs() const;
+       virtual unsigned int nargs() const;
 
        ///
-       virtual MathArray & cell(int);
+       virtual MathArray & cell(unsigned int);
        ///
-       virtual MathArray const & cell(int) const;
+       virtual MathArray const & cell(unsigned int) const;
        ///
-       virtual MathXArray & xcell(int);
+       virtual MathXArray & xcell(unsigned int);
        ///
-       virtual MathXArray const & xcell(int) const;
+       virtual MathXArray const & xcell(unsigned int) const;
                        
        ///
        virtual int xo() const;
@@ -131,25 +132,25 @@ public:
        ///
 
        ///
-       virtual int ncols() const { return 1; }
+       virtual unsigned int ncols() const { return 1; }
        ///
-       virtual int nrows() const { return 1; }
+       virtual unsigned int nrows() const { return 1; }
        ///
-       virtual int col(int) const { return 0; }
+       virtual unsigned int col(unsigned int) const { return 0; }
        ///
-       virtual int row(int) const { return 0; }
+       virtual unsigned int row(unsigned int) const { return 0; }
        ///
-       virtual int cellXOffset(int) const { return 0; }
+       virtual int cellXOffset(unsigned int) const { return 0; }
        ///
-       virtual int cellYOffset(int) const { return 0; }
+       virtual int cellYOffset(unsigned int) const { return 0; }
        ///
-       virtual void addRow(int) {}
+       virtual void addRow(unsigned int) {}
        ///
-       virtual void delRow(int) {}
+       virtual void delRow(unsigned int) {}
        ///
-       virtual void addCol(int) {}
+       virtual void addCol(unsigned int) {}
        ///
-       virtual void delCol(int) {}
+       virtual void delCol(unsigned int) {}
 
        ///
        virtual void userSetSize(MathStyles &) {}

diff --git a/src/mathed/math_macro.C b/src/mathed/math_macro.C
index 48506e85941795dd6cc654c0b347c835191897f8..56c5cb9c42bedad6c5ce0b2d45db04c25f37d544 100644 (file)
--- a/src/mathed/math_macro.C
+++ b/src/mathed/math_macro.C
@@ -72,7 +72,7 @@ void MathMacro::metrics(MathStyles st) const
                int lwid;
                mathed_string_dim(LM_TC_TEXTRM, size_, "#1: ", lasc, ldes, lwid);
 
-               for (int i = 0; i < nargs(); ++i) {
+               for (unsigned int i = 0; i < nargs(); ++i) {
                        MathXArray const & c = xcell(i);
                        c.metrics(st);
                        width_    = std::max(width_, c.width() + lwid);
@@ -114,7 +114,7 @@ void MathMacro::draw(Painter & pain, int x, int y) const
                int lwid;
                mathed_string_dim(LM_TC_TEXTRM, size_, "#1: ", lasc, ldes, lwid);
 
-               for (int i = 0; i < nargs(); ++i) {
+               for (unsigned int i = 0; i < nargs(); ++i) {
                        MathXArray const & c = xcell(i);
                        h += std::max(c.ascent(), lasc) + 5;
                        c.draw(pain, x + lwid, h);
@@ -134,20 +134,20 @@ void MathMacro::draw(Painter & pain, int x, int y) const
 }
 
 
-void MathMacro::dump(std::ostream & os) const
+void MathMacro::dump() const
 {
        MathMacroTable::dump();
-       os << "\n macro: '" << this << "'\n";
-       os << " name: '" << name() << "'\n";
-       os << " template: '" << tmplate_ << "'\n";
-       os << " template: '" << *tmplate_ << "'\n";
-       os << endl;
+       lyxerr << "\n macro: '" << this << "'\n";
+       lyxerr << " name: '" << name() << "'\n";
+       lyxerr << " template: '" << tmplate_ << "'\n";
+       lyxerr << " template: '" << *tmplate_ << "'\n";
+       lyxerr << endl;
 }
 
 void MathMacro::write(std::ostream & os, bool fragile) const
 {
        os << '\\' << name();
-       for (int i = 0; i < nargs(); ++i) {
+       for (unsigned int i = 0; i < nargs(); ++i) {
                os << '{';
                cell(i).write(os, fragile);
                os << '}';
@@ -160,7 +160,7 @@ void MathMacro::write(std::ostream & os, bool fragile) const
 void MathMacro::writeNormal(std::ostream & os) const
 {
        os << "[macro " << name() << " ";
-       for (int i = 0; i < nargs(); ++i) {
+       for (unsigned int i = 0; i < nargs(); ++i) {
                cell(i).writeNormal(os);
                os << ' ';
        }
@@ -168,25 +168,25 @@ void MathMacro::writeNormal(std::ostream & os) const
 }
 
 
-bool MathMacro::idxUp(int & idx, int & pos) const
+bool MathMacro::idxUp(unsigned int & idx, unsigned int & pos) const
 {
        return MathNestInset::idxLeft(idx, pos);
 }
 
 
-bool MathMacro::idxDown(int & idx, int & pos) const
+bool MathMacro::idxDown(unsigned int & idx, unsigned int & pos) const
 {
        return MathNestInset::idxRight(idx, pos);
 }
 
 
-bool MathMacro::idxLeft(int &, int &) const
+bool MathMacro::idxLeft(unsigned int &, unsigned int &) const
 {
        return false;
 }
 
 
-bool MathMacro::idxRight(int &, int &) const
+bool MathMacro::idxRight(unsigned int &, unsigned int &) const
 {
        return false;
 }

diff --git a/src/mathed/math_macro.h b/src/mathed/math_macro.h
index 30872fcdb3505f2f3668e1327e0a6fc1af05a840..ed8067bde531c8f3c76905e04cd71a29f1024fcb 100644 (file)
--- a/src/mathed/math_macro.h
+++ b/src/mathed/math_macro.h
@@ -51,16 +51,16 @@ public:
        ///
        void writeNormal(std::ostream &) const;
        ///
-       void dump(std::ostream & os) const;
+       void dump() const;
 
        ///
-       bool idxUp(int &, int &) const;
+       bool idxUp(unsigned int &, unsigned int &) const;
        ///
-       bool idxDown(int &, int &) const;
+       bool idxDown(unsigned int &, unsigned int &) const;
        ///
-       bool idxLeft(int &, int &) const;
+       bool idxLeft(unsigned int &, unsigned int &) const;
        ///
-       bool idxRight(int &, int &) const;
+       bool idxRight(unsigned int &, unsigned int &) const;
 
        ///
        void validate(LaTeXFeatures &) const;
@@ -80,9 +80,4 @@ private:
 };
 
 
-inline std::ostream & operator<<(std::ostream & os, MathMacro const & m)
-{
-       m.dump(os);
-       return os;
-}
 #endif

diff --git a/src/mathed/math_matrixinset.C b/src/mathed/math_matrixinset.C
index cc2610e36992bc512fc74aa0be5aea7e4ed3d6b5..29ae980d20714d9d1e035bf9a548fde6b17b38e3 100644 (file)
--- a/src/mathed/math_matrixinset.C
+++ b/src/mathed/math_matrixinset.C
@@ -64,7 +64,7 @@ MathMatrixInset::MathMatrixInset(MathInsetTypes t)
 }
 
 
-MathMatrixInset::MathMatrixInset(MathInsetTypes t, int cols)
+MathMatrixInset::MathMatrixInset(MathInsetTypes t, unsigned int cols)
        : MathGridInset(cols, 1), objtype_(t), nonum_(1), label_(1)
 {
        setDefaults();
@@ -77,7 +77,7 @@ MathInset * MathMatrixInset::clone() const
 }
 
 
-char MathMatrixInset::defaultColAlign(int col)
+char MathMatrixInset::defaultColAlign(unsigned int col)
 {
        switch (getType()) {
                case LM_OT_ALIGN:
@@ -93,7 +93,7 @@ char MathMatrixInset::defaultColAlign(int col)
 }
 
 
-int MathMatrixInset::defaultColSpace(int col)
+int MathMatrixInset::defaultColSpace(unsigned int col)
 {
        switch (getType()) {
                case LM_OT_ALIGN:
@@ -123,7 +123,7 @@ void MathMatrixInset::metrics(MathStyles) const
 
        if (numberedType()) {
                int l = 0;
-               for (int row = 0; row < nrows(); ++row)
+               for (unsigned int row = 0; row < nrows(); ++row)
                        l = std::max(l, mathed_string_width(LM_TC_BF, size(), nicelabel(row)));
 
                if (l)
@@ -148,7 +148,7 @@ void MathMatrixInset::draw(Painter & pain, int x, int y) const
 
        if (numberedType()) {
                int xx = x + colinfo_.back().offset_ + colinfo_.back().width_ + 20;
-               for (int row = 0; row < nrows(); ++row) {
+               for (unsigned int row = 0; row < nrows(); ++row) {
                        int yy = y + rowinfo_[row].offset_;
                        drawStr(pain, LM_TC_BF, size(), xx, yy, nicelabel(row));
                }
@@ -162,8 +162,8 @@ void MathMatrixInset::write(std::ostream & os, bool fragile) const
 
        bool n = numberedType();
 
-       for (int row = 0; row < nrows(); ++row) {
-               for (int col = 0; col < ncols(); ++col) {
+       for (unsigned int row = 0; row < nrows(); ++row) {
+               for (unsigned int col = 0; col < ncols(); ++col) {
                        cell(index(row, col)).write(os, fragile);
                        os << eocString(col);
                }
@@ -180,25 +180,25 @@ void MathMatrixInset::write(std::ostream & os, bool fragile) const
 }
 
 
-string MathMatrixInset::label(int row) const
+string MathMatrixInset::label(unsigned int row) const
 {
        return label_[row];
 }
 
 
-void MathMatrixInset::label(int row, string const & label)
+void MathMatrixInset::label(unsigned int row, string const & label)
 {
        label_[row] = label; 
 }
 
 
-void MathMatrixInset::numbered(int row, bool num)
+void MathMatrixInset::numbered(unsigned int row, bool num)
 {
        nonum_[row] = !num; 
 }
 
 
-bool MathMatrixInset::numbered(int row) const
+bool MathMatrixInset::numbered(unsigned int row) const
 {
        return !nonum_[row];
 }
@@ -219,7 +219,7 @@ bool MathMatrixInset::display() const
 std::vector<string> const MathMatrixInset::getLabelList() const
 {
        std::vector<string> res;
-       for (int row = 0; row < nrows(); ++row)
+       for (unsigned int row = 0; row < nrows(); ++row)
                if (!label_[row].empty() && nonum_[row] != 1)
                        res.push_back(label_[row]);
        return res;
@@ -230,7 +230,7 @@ bool MathMatrixInset::numberedType() const
 {
        if (getType() == LM_OT_SIMPLE || getType() == LM_OT_XXALIGNAT)
                return false;
-       for (int row = 0; row < nrows(); ++row)
+       for (unsigned int row = 0; row < nrows(); ++row)
                if (!nonum_[row])
                        return true;
        return false;
@@ -355,7 +355,7 @@ void MathMatrixInset::footer_write(std::ostream & os) const
 }
 
 
-void MathMatrixInset::addRow(int row) 
+void MathMatrixInset::addRow(unsigned int row) 
 {
        nonum_.insert(nonum_.begin() + row + 1, !numberedType());
        label_.insert(label_.begin() + row + 1, string());
@@ -371,7 +371,7 @@ void MathMatrixInset::appendRow()
 }
 
 
-void MathMatrixInset::delRow(int row) 
+void MathMatrixInset::delRow(unsigned int row) 
 {
        MathGridInset::delRow(row);
        nonum_.erase(nonum_.begin() + row);
@@ -379,7 +379,7 @@ void MathMatrixInset::delRow(int row)
 }
 
 
-void MathMatrixInset::addCol(int col)
+void MathMatrixInset::addCol(unsigned int col)
 {
        switch (getType()) {
                case LM_OT_EQUATION:
@@ -409,7 +409,7 @@ void MathMatrixInset::addCol(int col)
 }
 
 
-void MathMatrixInset::delCol(int col)
+void MathMatrixInset::delCol(unsigned int col)
 {
        switch (getType()) {
                case LM_OT_ALIGNAT:
@@ -424,7 +424,7 @@ void MathMatrixInset::delCol(int col)
 }
 
 
-string MathMatrixInset::nicelabel(int row) const
+string MathMatrixInset::nicelabel(unsigned int row) const
 {
        if (nonum_[row])
                return string();
@@ -459,6 +459,7 @@ namespace {
        }       
 }
 
+
 void MathMatrixInset::mutate(string const & newtype)
 {
        if (newtype == "dump") {
@@ -469,10 +470,11 @@ void MathMatrixInset::mutate(string const & newtype)
        mutate(typecode(newtype));
 }
 
+
 void MathMatrixInset::glueall()
 {
        MathArray ar;
-       for (int i = 0; i < nargs(); ++i)
+       for (unsigned int i = 0; i < nargs(); ++i)
                ar.push_back(cell(i));
        *this = MathMatrixInset(LM_OT_SIMPLE);
        cell(0) = ar;
@@ -521,7 +523,7 @@ void MathMatrixInset::mutate(MathInsetTypes newtype)
                                        MathGridInset::addCol(1);
 
                                        // split it "nicely"
-                                       int pos = firstRelOp(cell(0));  
+                                       unsigned int pos = firstRelOp(cell(0)); 
                                        cell(1) = cell(0);
                                        cell(0).erase(pos, cell(0).size());
                                        cell(1).erase(0, pos);
@@ -536,7 +538,7 @@ void MathMatrixInset::mutate(MathInsetTypes newtype)
                                        MathGridInset::addCol(1);
 
                                        // split it "nicely" on the firest relop
-                                       int pos = firstRelOp(cell(0));  
+                                       unsigned int pos = firstRelOp(cell(0)); 
                                        cell(1) = cell(0);
                                        cell(0).erase(pos, cell(0).size());
                                        cell(1).erase(0, pos);
@@ -559,16 +561,16 @@ void MathMatrixInset::mutate(MathInsetTypes newtype)
                                case LM_OT_EQUATION: {
                                        // set correct (no)numbering
                                        bool allnonum = true;
-                                       for (int r = 0; r < nrows(); ++r) {
-                                               if (!nonum_[r])
+                                       for (unsigned int row = 0; row < nrows(); ++row) {
+                                               if (!nonum_[row])
                                                        allnonum = false;
                                        }
 
                                        // set first non-empty label
                                        string label;
-                                       for (int r = 0; r < nrows(); ++r) {
-                                               if (!label_[r].empty()) {
-                                                       label = label_[r];
+                                       for (unsigned int row = 0; row < nrows(); ++row) {
+                                               if (!label_[row].empty()) {
+                                                       label = label_[row];
                                                        break;
                                                }
                                        }
@@ -586,8 +588,8 @@ void MathMatrixInset::mutate(MathInsetTypes newtype)
                                case LM_OT_XALIGNAT:
                                case LM_OT_XXALIGNAT:
                                default: {
-                                       for (int row = 0; row < nrows(); ++row) {
-                                               int c = 3 * row + 1;
+                                       for (unsigned int row = 0; row < nrows(); ++row) {
+                                               unsigned int c = 3 * row + 1;
                                                cell(c).push_back(cell(c + 1));
                                        }
                                        MathGridInset::delCol(2);

diff --git a/src/mathed/math_matrixinset.h b/src/mathed/math_matrixinset.h
index 0bacd405346cef6b274502d0663222b6be9e310b..823eab9bbd8175d403e32ad9adac33ef9147f86e 100644 (file)
--- a/src/mathed/math_matrixinset.h
+++ b/src/mathed/math_matrixinset.h
@@ -23,7 +23,7 @@ public:
        ///
        explicit MathMatrixInset(MathInsetTypes t);
        ///
-       MathMatrixInset(MathInsetTypes t, int cols);
+       MathMatrixInset(MathInsetTypes t, unsigned int cols);
        ///
        MathInset * clone() const;
        ///
@@ -33,13 +33,13 @@ public:
        ///
        void draw(Painter &, int x, int y) const;
        ///
-       string label(int row) const;
+       string label(unsigned int row) const;
        ///
-       void label(int row, string const & label);
+       void label(unsigned int row, string const & label);
        ///
-       void numbered(int row, bool num);
+       void numbered(unsigned int row, bool num);
        ///
-       bool numbered(int row) const;
+       bool numbered(unsigned int row) const;
        ///
        bool numberedType() const;
        ///
@@ -52,13 +52,13 @@ public:
        void validate(LaTeXFeatures & features) const;
 
        ///
-       void addRow(int);
+       void addRow(unsigned int);
        ///
-       void delRow(int);
+       void delRow(unsigned int);
        ///
-       void addCol(int);
+       void addCol(unsigned int);
        ///
-       void delCol(int);
+       void delCol(unsigned int);
        ///
        void appendRow();
 
@@ -68,9 +68,9 @@ public:
        void mutate(MathInsetTypes);
 
        ///
-       int defaultColSpace(int col);
+       int defaultColSpace(unsigned int col);
        ///
-       char defaultColAlign(int col);
+       char defaultColAlign(unsigned int col);
 
        ///
        MathInsetTypes getType() const;
@@ -87,7 +87,7 @@ private:
        ///
        void glueall();
        ///
-       string nicelabel(int row) const;
+       string nicelabel(unsigned int row) const;
 
        ///
        MathInsetTypes objtype_;

diff --git a/src/mathed/math_nestinset.C b/src/mathed/math_nestinset.C
index aae1db633ddefaf81154da6a0e61a6cd91aa6f53..fc316df70ca69566088d5ddc47a36fd1c3298299 100644 (file)
--- a/src/mathed/math_nestinset.C
+++ b/src/mathed/math_nestinset.C
@@ -6,36 +6,36 @@
 #include "debug.h"
 
 
-MathNestInset::MathNestInset(int nargs)
+MathNestInset::MathNestInset(unsigned int nargs)
        : MathDimInset(), cells_(nargs)
 {}
 
 
-int MathNestInset::nargs() const
+unsigned int MathNestInset::nargs() const
 {
        return cells_.size();
 }
 
 
-MathXArray & MathNestInset::xcell(int i)
+MathXArray & MathNestInset::xcell(unsigned int i)
 {
        return cells_[i];
 }
 
 
-MathXArray const & MathNestInset::xcell(int i) const
+MathXArray const & MathNestInset::xcell(unsigned int i) const
 {
        return cells_[i];
 }
 
 
-MathArray & MathNestInset::cell(int i)
+MathArray & MathNestInset::cell(unsigned int i)
 {
        return cells_[i].data_;
 }
 
 
-MathArray const & MathNestInset::cell(int i) const
+MathArray const & MathNestInset::cell(unsigned int i) const
 {
        return cells_[i].data_;
 }
@@ -43,7 +43,7 @@ MathArray const & MathNestInset::cell(int i) const
 
 void MathNestInset::substitute(MathMacro const & m)
 {
-       for (int i = 0; i < nargs(); ++i)
+       for (unsigned int i = 0; i < nargs(); ++i)
                cell(i).substitute(m);
 }
 
@@ -51,7 +51,7 @@ void MathNestInset::substitute(MathMacro const & m)
 void MathNestInset::metrics(MathStyles st) const
 {
        size_ = st;
-       for (int i = 0; i < nargs(); ++i)
+       for (unsigned int i = 0; i < nargs(); ++i)
                xcell(i).metrics(st);
 }
 
@@ -60,12 +60,12 @@ void MathNestInset::draw(Painter & pain, int x, int y) const
 {
        xo(x);
        yo(y);
-       for (int i = 0; i < nargs(); ++i)
+       for (unsigned int i = 0; i < nargs(); ++i)
                xcell(i).draw(pain, x + xcell(i).xo(), y + xcell(i).yo());
 }
 
 
-bool MathNestInset::idxNext(int & idx, int & pos) const
+bool MathNestInset::idxNext(unsigned int & idx, unsigned int & pos) const
 {
        if (idx + 1 >= nargs())
                return false;
@@ -75,13 +75,13 @@ bool MathNestInset::idxNext(int & idx, int & pos) const
 }
 
 
-bool MathNestInset::idxRight(int & idx, int & pos) const
+bool MathNestInset::idxRight(unsigned int & idx, unsigned int & pos) const
 {
        return idxNext(idx, pos);
 }
 
 
-bool MathNestInset::idxPrev(int & idx, int & pos) const
+bool MathNestInset::idxPrev(unsigned int & idx, unsigned int & pos) const
 {
        if (idx == 0)
                return false;
@@ -91,13 +91,13 @@ bool MathNestInset::idxPrev(int & idx, int & pos) const
 }
 
 
-bool MathNestInset::idxLeft(int & idx, int & pos) const
+bool MathNestInset::idxLeft(unsigned int & idx, unsigned int & pos) const
 {
        return idxPrev(idx, pos);
 }
 
 
-bool MathNestInset::idxFirst(int & i, int & pos) const
+bool MathNestInset::idxFirst(unsigned int & i, unsigned int & pos) const
 {
        if (nargs() == 0)
                return false;
@@ -107,7 +107,7 @@ bool MathNestInset::idxFirst(int & i, int & pos) const
 }
 
 
-bool MathNestInset::idxLast(int & i, int & pos) const
+bool MathNestInset::idxLast(unsigned int & i, unsigned int & pos) const
 {
        if (nargs() == 0)
                return false;
@@ -117,7 +117,7 @@ bool MathNestInset::idxLast(int & i, int & pos) const
 }
 
 
-bool MathNestInset::idxHome(int & /* idx */, int & pos) const
+bool MathNestInset::idxHome(unsigned int & /* idx */, unsigned int & pos) const
 {
        if (pos == 0)
                return false;
@@ -126,9 +126,9 @@ bool MathNestInset::idxHome(int & /* idx */, int & pos) const
 }
 
 
-bool MathNestInset::idxEnd(int & idx, int & pos) const
+bool MathNestInset::idxEnd(unsigned int & idx, unsigned int & pos) const
 {
-       int n = cell(idx).size();
+       unsigned int n = cell(idx).size();
        if (pos == n)
                return false;
 
@@ -142,7 +142,7 @@ void MathNestInset::dump() const
        lyxerr << "---------------------------------------------\n";
        write(lyxerr, false);
        lyxerr << "\n";
-       for (int i = 0; i < nargs(); ++i)
+       for (unsigned int i = 0; i < nargs(); ++i)
                lyxerr << cell(i) << "\n";
        lyxerr << "---------------------------------------------\n";
 }
@@ -159,6 +159,6 @@ void MathNestInset::push_back(MathInset * p)
 
 void MathNestInset::validate(LaTeXFeatures & features) const
 {
-       for (int i = 0; i < nargs(); ++i)
+       for (unsigned int i = 0; i < nargs(); ++i)
                cell(i).validate(features);
 }

diff --git a/src/mathed/math_nestinset.h b/src/mathed/math_nestinset.h
index 123fc267497b1c12e2eed65ea5d1f1a8d1623cec..5a69d88be92ce2d8b9de3da638a977097be04e98 100644 (file)
--- a/src/mathed/math_nestinset.h
+++ b/src/mathed/math_nestinset.h
@@ -16,7 +16,7 @@ class LaTeXFeatures;
 class MathNestInset : public MathDimInset {
 public: 
        ///
-       explicit MathNestInset(int ncells);
+       explicit MathNestInset(unsigned int ncells);
 
        ///
        void metrics(MathStyles st) const;
@@ -26,36 +26,36 @@ public:
        void substitute(MathMacro const & macro); 
 
        /// The left key
-       bool idxLeft(int & idx, int & pos) const;
+       bool idxLeft(unsigned int & idx, unsigned int & pos) const;
        /// The right key
-       bool idxRight(int & idx, int & pos) const;
+       bool idxRight(unsigned int & idx, unsigned int & pos) const;
 
        /// Move one physical cell up
-       bool idxNext(int & idx, int & pos) const;
+       bool idxNext(unsigned int & idx, unsigned int & pos) const;
        /// Move one physical cell down
-       bool idxPrev(int & idx, int & pos) const;
+       bool idxPrev(unsigned int & idx, unsigned int & pos) const;
 
        /// Target pos when we enter the inset from the left by pressing "Right"
-       bool idxFirst(int & idx, int & pos) const;
+       bool idxFirst(unsigned int & idx, unsigned int & pos) const;
        /// Target pos when we enter the inset from the right by pressing "Left"
-       bool idxLast(int & idx, int & pos) const;
+       bool idxLast(unsigned int & idx, unsigned int & pos) const;
 
        /// Where should we go if we press home?
-       bool idxHome(int & idx, int & pos) const;
+       bool idxHome(unsigned int & idx, unsigned int & pos) const;
        /// Where should we go if we press end?
-       bool idxEnd(int & idx, int & pos) const;
+       bool idxEnd(unsigned int & idx, unsigned int & pos) const;
 
        ///
-       int nargs() const;
+       unsigned int nargs() const;
 
        ///
-       MathArray & cell(int);
+       MathArray & cell(unsigned int);
        ///
-       MathArray const & cell(int) const;
+       MathArray const & cell(unsigned int) const;
        ///
-       MathXArray & xcell(int);
+       MathXArray & xcell(unsigned int);
        ///
-       MathXArray const & xcell(int) const;
+       MathXArray const & xcell(unsigned int) const;
                        
        ///
        bool isActive() const { return nargs() > 0; }

diff --git a/src/mathed/math_parser.C b/src/mathed/math_parser.C
index a63b0b0fbab0f48c58f1319e637f67a2dfef5006..18766700e37c3bd16dd972b404597f445f137837 100644 (file)
--- a/src/mathed/math_parser.C
+++ b/src/mathed/math_parser.C
@@ -880,7 +880,7 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
 
                                else {
                                        MathInset * p = createMathInset(t.cs());
-                                       for (int i = 0; i < p->nargs(); ++i) 
+                                       for (unsigned int i = 0; i < p->nargs(); ++i) 
                                                parse_into(p->cell(i), FLAG_ITEM);
                                        array.push_back(p);
                                }
@@ -889,7 +889,7 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
                        else {
                                MathInset * p = createMathInset(t.cs());
                                if (p) {
-                                       for (int i = 0; i < p->nargs(); ++i)
+                                       for (unsigned int i = 0; i < p->nargs(); ++i)
                                                parse_into(p->cell(i), FLAG_ITEM);
                                        array.push_back(p);
                                } else {