gcc3.x fixes

11 files changed, 74 insertions, 32 deletions

diff --git a/noncore/apps/opie-sheet/cellformat.cpp b/noncore/apps/opie-sheet/cellformat.cpp
index 597502c..342ebe9 100644
--- a/noncore/apps/opie-sheet/cellformat.cpp
+++ b/noncore/apps/opie-sheet/cellformat.cpp
@@ -1,599 +1,626 @@
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include "cellformat.h"
 
 #include <qlistbox.h>
 #include <qlabel.h>
 
 #define COMBO_WIDTHS 155
 #define COMBO_HEIGHTS 21
 
 #define COLOR_COUNT 17
 #define STYLE_COUNT 14
 #define HALIGN_COUNT 3
 #define VALIGN_COUNT 3
 
-QColor qtColors[COLOR_COUNT]={Qt::black, Qt::white, Qt::darkGray, Qt::gray, Qt::lightGray, Qt::red, Qt::green, Qt::blue, Qt::cyan, Qt::magenta, Qt::yellow, Qt::darkRed, Qt::darkGreen, Qt::darkBlue, Qt::darkCyan, Qt::darkMagenta, Qt::darkYellow};
-Qt::BrushStyle brushStyles[STYLE_COUNT]={Qt::SolidPattern, Qt::Dense1Pattern, Qt::Dense2Pattern, Qt::Dense3Pattern, Qt::Dense4Pattern, Qt::Dense5Pattern, Qt::Dense6Pattern, Qt::Dense7Pattern, Qt::HorPattern, Qt::VerPattern, Qt::CrossPattern, Qt::BDiagPattern, Qt::FDiagPattern, Qt::DiagCrossPattern};
+QColor qtColors[COLOR_COUNT]={Qt::black,Qt::white, Qt::darkGray,
+                              Qt::gray, Qt::lightGray, Qt::red,
+                              Qt::green, Qt::blue, Qt::cyan,
+                              Qt::magenta, Qt::yellow,
+                              Qt::darkRed, Qt::darkGreen,
+                              Qt::darkBlue, Qt::darkCyan,
+                              Qt::darkMagenta, Qt::darkYellow};
+
+Qt::BrushStyle brushStyles[STYLE_COUNT]={Qt::SolidPattern,
+                                         Qt::Dense1Pattern, Qt::Dense2Pattern,
+                                         Qt::Dense3Pattern, Qt::Dense4Pattern,
+                                         Qt::Dense5Pattern, Qt::Dense6Pattern,
+                                         Qt::Dense7Pattern, Qt::HorPattern,
+                                         Qt::VerPattern, Qt::CrossPattern,
+                                         Qt::BDiagPattern, Qt::FDiagPattern,
+                                         Qt::DiagCrossPattern};
+
 QString namesHAlign[HALIGN_COUNT]={"Left", "Right", "Center"};
 QString namesVAlign[VALIGN_COUNT]={"Top", "Bottom", "Center"};
-Qt::AlignmentFlags flagsHAlign[HALIGN_COUNT]={Qt::AlignLeft, Qt::AlignRight, Qt::AlignHCenter};
-Qt::AlignmentFlags flagsVAlign[VALIGN_COUNT]={Qt::AlignTop, Qt::AlignBottom, Qt::AlignVCenter};
 
-CellFormat::CellFormat(QWidget *parent=0)
+Qt::AlignmentFlags flagsHAlign[HALIGN_COUNT]={Qt::AlignLeft,
+                                              Qt::AlignRight,
+                                              Qt::AlignHCenter};
+
+Qt::AlignmentFlags flagsVAlign[VALIGN_COUNT]={Qt::AlignTop,
+                                              Qt::AlignBottom,
+                                              Qt::AlignVCenter};
+
+CellFormat::CellFormat(QWidget *parent)
            :QDialog(parent, 0, TRUE)
 {
   // Main widget
   tabs=new QTabWidget(this);
   widgetBorders=new QWidget(tabs);
   widgetBackground=new QWidget(tabs);
   widgetFont=new QWidget(tabs);
   widgetAlignment=new QWidget(tabs);
   tabs->addTab(widgetBorders, tr("&Borders"));
   tabs->addTab(widgetBackground, tr("Back&ground"));
   tabs->addTab(widgetFont, tr("&Font"));
   tabs->addTab(widgetAlignment, tr("&Alignment"));
 
   fontDB.loadRenderers();
   changedFont=changedAlign=changedBrush=FALSE;
 
   // Borders tab
   borderEditor=new BorderEditor(widgetBorders);
   borderEditor->setGeometry(10, 10, 215, 145);
-  connect(borderEditor, SIGNAL(clicked(BorderEditor::BorderArea)), this, SLOT(borderClicked(BorderEditor::BorderArea)));
+  connect(borderEditor, SIGNAL(clicked(BorderEditor::BorderArea)),
+          this, SLOT(borderClicked(BorderEditor::BorderArea)));
 
   comboBordersWidth=createCombo(COMBO_WIDTH, widgetBorders, tr("&Width:"), 165);
   comboBordersColor=createCombo(COMBO_COLOR, widgetBorders, tr("&Color:"), 165+(COMBO_HEIGHTS+10));
 
   buttonBordersDefaults=new QPushButton(tr("&Default Borders"), widgetBorders);
-  buttonBordersDefaults->setGeometry(115, 165+2*(COMBO_HEIGHTS+10), 110, COMBO_HEIGHTS);
-  connect(buttonBordersDefaults, SIGNAL(clicked()), this, SLOT(slotBordersDefaults()));
+  buttonBordersDefaults->setGeometry(115, 165+2*(COMBO_HEIGHTS+10),
+                                     110, COMBO_HEIGHTS);
+
+  connect(buttonBordersDefaults, SIGNAL(clicked()),
+          this, SLOT(slotBordersDefaults()));
 
   // Background tab
   frameBackground=new QFrame(widgetBackground);
   frameBackground->setGeometry(10, 10, 215, 145);
   frameBackground->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 
   comboBackgroundStyle=createCombo(COMBO_STYLE, widgetBackground, tr("&Style:"), 165);
   connect(comboBackgroundStyle, SIGNAL(activated(int)), this, SLOT(backgroundClicked(int)));
   comboBackgroundColor=createCombo(COMBO_COLOR, widgetBackground, tr("&Color:"), 165+(COMBO_HEIGHTS+10));
   connect(comboBackgroundColor, SIGNAL(activated(int)), this, SLOT(backgroundClicked(int)));
 
   buttonBackgroundDefaults=new QPushButton(tr("&Default Background"), widgetBackground);
   buttonBackgroundDefaults->setGeometry(115, 165+2*(COMBO_HEIGHTS+10), 110, COMBO_HEIGHTS);
   connect(buttonBackgroundDefaults, SIGNAL(clicked()), this, SLOT(slotBackgroundDefaults()));
 
   // Font tab
   frameFont=new QFrame(widgetFont);
   frameFont->setGeometry(10, 10, 215, 125);
   frameFont->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 
   comboFontFamily=createCombo(COMBO_FONT, widgetFont, tr("&Font:"), 145);
   connect(comboFontFamily, SIGNAL(activated(int)), this, SLOT(fontClicked(int)));
   comboFontSize=createCombo(COMBO_SIZE, widgetFont, tr("&Size:"), 145+(COMBO_HEIGHTS+10));
   connect(comboFontSize, SIGNAL(activated(int)), this, SLOT(fontClicked(int)));
   comboFontColor=createCombo(COMBO_COLOR, widgetFont, tr("&Color:"), 145+2*(COMBO_HEIGHTS+10));
   connect(comboFontColor, SIGNAL(activated(int)), this, SLOT(fontClicked(int)));
 
   checkFontBold=new QCheckBox(tr("&Bold"), widgetFont);
   checkFontBold->setGeometry(10, 145+3*(COMBO_HEIGHTS+10), 40, COMBO_HEIGHTS);
   connect(checkFontBold, SIGNAL(toggled(bool)), this, SLOT(fontClicked(bool)));
   checkFontItalic=new QCheckBox(tr("&Italic"), widgetFont);
   checkFontItalic->setGeometry(60, 145+3*(COMBO_HEIGHTS+10), 40, COMBO_HEIGHTS);
   connect(checkFontItalic, SIGNAL(toggled(bool)), this, SLOT(fontClicked(bool)));
 
   buttonFontDefaults=new QPushButton(tr("&Default Font"), widgetFont);
   buttonFontDefaults->setGeometry(115, 145+3*(COMBO_HEIGHTS+10), 110, COMBO_HEIGHTS);
   connect(buttonFontDefaults, SIGNAL(clicked()), this, SLOT(slotFontDefaults()));
 
   // Alignment tab
   frameAlignment=new QFrame(widgetAlignment);
   frameAlignment->setGeometry(10, 10, 215, 145);
   frameAlignment->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 
   comboAlignmentVertical=createCombo(COMBO_VALIGN, widgetAlignment, tr("&Vertical:"), 165);
   connect(comboAlignmentVertical, SIGNAL(activated(int)), this, SLOT(alignClicked(int)));
   comboAlignmentHorizontal=createCombo(COMBO_HALIGN, widgetAlignment, tr("&Horizontal:"), 165+(COMBO_HEIGHTS+10));
   connect(comboAlignmentHorizontal, SIGNAL(activated(int)), this, SLOT(alignClicked(int)));
 
   checkAlignmentWrap=new QCheckBox(tr("&Word Wrap"), widgetAlignment);
   checkAlignmentWrap->setGeometry(10, 165+2*(COMBO_HEIGHTS+10), 90, COMBO_HEIGHTS);
   connect(checkAlignmentWrap, SIGNAL(toggled(bool)), this, SLOT(alignClicked(bool)));
 
   buttonAlignmentDefaults=new QPushButton(tr("&Default Alignment"), widgetAlignment);
   buttonAlignmentDefaults->setGeometry(115, 165+2*(COMBO_HEIGHTS+10), 110, COMBO_HEIGHTS);
   connect(buttonAlignmentDefaults, SIGNAL(clicked()), this, SLOT(slotAlignmentDefaults()));
 
   // Main widget
   box=new QVBoxLayout(this);
   box->addWidget(tabs);
 
   setCaption(tr("Format Cells"));
 }
 
 CellFormat::~CellFormat()
 {
 }
 
 int CellFormat::findColorIndex(const QColor &color)
 {
   for (int i=0; i<COLOR_COUNT; ++i)
     if (qtColors[i]==color)
       return i;
   return 0;
 }
 
 int CellFormat::findVAlignIndex(Qt::AlignmentFlags flag)
 {
   for (int i=0; i<VALIGN_COUNT; ++i)
     if (flagsVAlign[i] & flag)
       return i;
   return 0;
 }
 
 int CellFormat::findHAlignIndex(Qt::AlignmentFlags flag)
 {
   for (int i=0; i<HALIGN_COUNT; ++i)
     if (flagsHAlign[i] & flag)
       return i;
   return 0;
 }
 
 int CellFormat::findBrushStyleIndex(Qt::BrushStyle style)
 {
   for (int i=0; i<STYLE_COUNT; ++i)
     if (brushStyles[i]==style)
       return i;
   return 0;
 }
 
 void CellFormat::setBrushBackground(const QBrush &brush)
 {
   comboBackgroundColor->setCurrentItem(findColorIndex(brush.color()));
   comboBackgroundStyle->setCurrentItem(findBrushStyleIndex(brush.style()));
 
   QPixmap pix(frameBackground->contentsRect().width(), frameBackground->contentsRect().height());
   QPainter p(&pix);
   pix.fill();
   p.fillRect(pix.rect(), brush);
   frameBackground->setBackgroundPixmap(pix);
 
   brushBackground=brush;
 }
 
 void CellFormat::setTextFont(const QFont &font, const QColor &color)
 {
   comboFontColor->setCurrentItem(findColorIndex(color));
   comboFontFamily->setCurrentItem(findComboItemIndex(comboFontFamily, font.family()));
   comboFontSize->setCurrentItem(findComboItemIndex(comboFontSize, QString::number(font.pointSize())));
   checkFontBold->setChecked(font.weight()==QFont::Bold);
   checkFontItalic->setChecked(font.italic());
 
   QPixmap pix(frameFont->contentsRect().width(), frameFont->contentsRect().height());
   QPainter p(&pix);
   pix.fill();
   p.fillRect(pix.rect(), Qt::white);
   p.setFont(font);
   p.setPen(color);
   p.drawText(pix.rect(), Qt::AlignCenter, tr("Opie Sheet"));
   frameFont->setBackgroundPixmap(pix);
 
   fontFont=font;
   fontColor=color;
 }
 
 void CellFormat::setTextAlign(Qt::AlignmentFlags flags)
 {
   comboAlignmentVertical->setCurrentItem(findVAlignIndex(flags));
   comboAlignmentHorizontal->setCurrentItem(findHAlignIndex(flags));
   checkAlignmentWrap->setChecked(flags & Qt::WordBreak);
 
   QPixmap pix(frameAlignment->contentsRect().width(), frameAlignment->contentsRect().height());
   QPainter p(&pix);
   pix.fill();
   p.fillRect(pix.rect(), Qt::white);
   p.drawText(10, 10, pix.width()-20, pix.height()-20, flags, tr("Opie Sheet"));
   frameAlignment->setBackgroundPixmap(pix);
 
   textAlignment=flags;
 }
 
 void CellFormat::slotFontDefaults()
 {
   changedFont=TRUE;
   setTextFont(font(), Qt::black);
 }
 
 void CellFormat::slotAlignmentDefaults()
 {
   changedAlign=TRUE;
   setTextAlign((Qt::AlignmentFlags)(Qt::AlignLeft | Qt::AlignTop));
 }
 
 void CellFormat::slotBackgroundDefaults()
 {
   changedBrush=TRUE;
   setBrushBackground(Qt::white);
 }
 
 void CellFormat::slotBordersDefaults()
 {
   QPen defaultPen(Qt::gray, 1, Qt::SolidLine);
   borderEditor->setPen(defaultPen, BorderEditor::Top);
   borderEditor->setPen(defaultPen, BorderEditor::Bottom);
   borderEditor->setPen(defaultPen, BorderEditor::Left);
   borderEditor->setPen(defaultPen, BorderEditor::Right);
   borderEditor->setPen(defaultPen, BorderEditor::Vert);
   borderEditor->setPen(defaultPen, BorderEditor::Horz);
 }
 
 void CellFormat::backgroundClicked(int index)
 {
   changedBrush=TRUE;
   setBrushBackground(QBrush(qtColors[comboBackgroundColor->currentItem()], brushStyles[comboBackgroundStyle->currentItem()]));
 }
 
 void CellFormat::fontClicked(bool on)
 {
   fontClicked(0);
 }
 
 void CellFormat::fontClicked(int index)
 {
   changedFont=TRUE;
   setTextFont(QFont(comboFontFamily->currentText(), comboFontSize->currentText().toInt(), checkFontBold->isChecked() ? QFont::Bold : QFont::Normal, checkFontItalic->isChecked(), QFont::AnyCharSet), qtColors[comboFontColor->currentItem()]);
 }
 
 void CellFormat::alignClicked(bool on)
 {
   alignClicked(0);
 }
 
 void CellFormat::alignClicked(int index)
 {
   changedAlign=TRUE;
   setTextAlign((Qt::AlignmentFlags)(flagsVAlign[comboAlignmentVertical->currentItem()] | flagsHAlign[comboAlignmentHorizontal->currentItem()] | (checkAlignmentWrap->isChecked() ? Qt::WordBreak : 0)));
 }
 
 void CellFormat::createSizeCombo(QComboBox *combo)
 {
   combo->clear();
   QValueList<int> sizes=fontDB.standardSizes();
   for (QValueList<int>::ConstIterator i=sizes.begin(); i!=sizes.end(); ++i)
     combo->insertItem(QString::number(*i));
 }
 
 void CellFormat::borderClicked(BorderEditor::BorderArea area)
 {
   QPen newPen(qtColors[comboBordersColor->currentItem()], comboBordersWidth->currentItem()+1, Qt::SolidLine);
   if (newPen==borderEditor->getPen(area))
     borderEditor->setPen(QPen(Qt::gray, 1, Qt::NoPen), area);
   else
     borderEditor->setPen(newPen, area);
 }
 
 int CellFormat::findComboItemIndex(QComboBox *combo, const QString &item)
 {
   for (int i=0; i<combo->count(); ++i)
     if (combo->text(i)==item)
       return i;
   return 0;
 }
 
-QComboBox *CellFormat::createCombo(comboType type, QWidget *parent, const QString &caption, int y)
+QComboBox *CellFormat::createCombo(comboType type, QWidget *parent,
+                                   const QString &caption, int y)
 {
   QComboBox *combo=new QComboBox(FALSE, parent);
   combo->setGeometry(70, y, COMBO_WIDTHS, COMBO_HEIGHTS);
   combo->setSizeLimit(5);
 
   switch (type)
   {
     case COMBO_WIDTH: createWidthCombo(combo); break;
     case COMBO_STYLE: createStyleCombo(combo); break;
     case COMBO_FONT: createFontCombo(combo); break;
     case COMBO_SIZE: createSizeCombo(combo); break;
     case COMBO_COLOR: createColorCombo(combo); break;
     case COMBO_HALIGN: createHAlignCombo(combo); break;
     case COMBO_VALIGN: createVAlignCombo(combo); break;
+  default: break;
   }
 
   QLabel *label=new QLabel(combo, caption, parent);
   label->setGeometry(10, y, 50, COMBO_HEIGHTS);
 
   return combo;
 }
 
 void CellFormat::createHAlignCombo(QComboBox *combo)
 {
   for (int i=0; i<HALIGN_COUNT; ++i)
     combo->insertItem(namesHAlign[i]);
 }
 
 void CellFormat::createVAlignCombo(QComboBox *combo)
 {
   for (int i=0; i<VALIGN_COUNT; ++i)
     combo->insertItem(namesVAlign[i]);
 }
 
 void CellFormat::createWidthCombo(QComboBox *combo)
 {
   int width=combo->listBox()->maxItemWidth();
   QPixmap pix(width, COMBO_HEIGHTS);
   QPainter p(&pix);
 
   for (int i=1; i<=6; ++i)
   {
     pix.fill();
     p.setPen(QPen(Qt::black, i, Qt::SolidLine));
     p.drawLine(5, COMBO_HEIGHTS/2, width-10, COMBO_HEIGHTS/2);
     combo->insertItem(pix);
   }
 }
 
 void CellFormat::createFontCombo(QComboBox *combo)
 {
   combo->insertStringList(fontDB.families());
 }
 
 void CellFormat::createStyleCombo(QComboBox *combo)
 {
   int width=combo->listBox()->maxItemWidth();
   QPixmap pix(width, COMBO_HEIGHTS);
   QPainter p(&pix);
 
   for (int i=0; i<STYLE_COUNT; ++i)
   {
     pix.fill();
     p.fillRect(5, 5, width-10, COMBO_HEIGHTS-10, brushStyles[i]);
     combo->insertItem(pix);
   }
 }
 
 void CellFormat::createColorCombo(QComboBox *combo)
 {
   int width=combo->listBox()->maxItemWidth();
   QPixmap pix(width, COMBO_HEIGHTS);
   QPainter p(&pix);
 
   for (int i=0; i<COLOR_COUNT; ++i)
   {
     pix.fill();
     p.setPen(QPen(qtColors[i], 3, Qt::SolidLine));
     p.drawLine(5, COMBO_HEIGHTS/2, width-10, COMBO_HEIGHTS/2);
     combo->insertItem(pix);
   }
 }
 
 int CellFormat::exec(Sheet *s)
 {
   sheet=s;
   int row1, row2, col1, col2, row, col;
   sheet->getSelection(&row1, &col1, &row2, &col2);
 
   QPen penTop=sheet->getPen(row1-1, col1, 0), penBottom=sheet->getPen(row2, col1, 0),
        penLeft=sheet->getPen(row1, col1-1, 1), penRight=sheet->getPen(row1, col2, 1),
        penVert=sheet->getPen(row1, col1, 1), penHorz=sheet->getPen(row1, col1, 0),
        penDefault=borderEditor->getDefaultPen();
   for (row=row1+1; row<=row2; ++row)
     if (sheet->getPen(row, col1-1, 1)!=penLeft)
     {
       penLeft=penDefault;
       break;
     }
   for (row=row1+1; row<=row2; ++row)
     if (sheet->getPen(row, col2, 1)!=penRight)
     {
       penRight=penDefault;
       break;
     }
   for (col=col1+1; col<=col2; ++col)
     if (sheet->getPen(row1-1, col, 0)!=penTop)
     {
       penTop=penDefault;
       break;
     }
   for (col=col1+1; col<=col2; ++col)
     if (sheet->getPen(row2, col, 0)!=penBottom)
     {
       penBottom=penDefault;
       break;
     }
   for (row=row1; row<=row2; ++row)
     for (col=col1; col<col2; ++col)
       if (sheet->getPen(row, col, 1)!=penVert)
       {
         penVert=penDefault;
         break;
       }
   for (row=row1; row<row2; ++row)
     for (col=col1; col<=col2; ++col)
       if (sheet->getPen(row, col, 0)!=penHorz)
       {
         penHorz=penDefault;
         break;
       }
 
   borderEditor->setPen(penTop, BorderEditor::Top);
   borderEditor->setPen(penBottom, BorderEditor::Bottom);
   borderEditor->setPen(penLeft, BorderEditor::Left);
   borderEditor->setPen(penRight, BorderEditor::Right);
   borderEditor->setPen(penVert, BorderEditor::Vert);
   borderEditor->setPen(penHorz, BorderEditor::Horz);
 
   setBrushBackground(sheet->getBrush(row1, col1));
   setTextFont(sheet->getFont(row1, col1), sheet->getFontColor(row1, col1));
   setTextAlign(sheet->getAlignment(row1, col1));
 
   if (QDialog::exec()==QDialog::Accepted)
   {
     penTop=borderEditor->getPen(BorderEditor::Top);
     penBottom=borderEditor->getPen(BorderEditor::Bottom);
     penLeft=borderEditor->getPen(BorderEditor::Left);
     penRight=borderEditor->getPen(BorderEditor::Right);
     penVert=borderEditor->getPen(BorderEditor::Vert);
     penHorz=borderEditor->getPen(BorderEditor::Horz);
 
     if (penTop!=penDefault)
       for (col=col1; col<=col2; ++col)
         sheet->setPen(row1-1, col, 0, penTop);
     if (penBottom!=penDefault)
       for (col=col1; col<=col2; ++col)
         sheet->setPen(row2, col, 0, penBottom);
     if (penLeft!=penDefault)
       for (row=row1; row<=row2; ++row)
         sheet->setPen(row, col1-1, 1, penLeft);
     if (penRight!=penDefault)
       for (row=row1; row<=row2; ++row)
         sheet->setPen(row, col2, 1, penRight);
     if (penVert!=penDefault)
       for (row=row1; row<=row2; ++row)
         for (col=col1; col<col2; ++col)
           sheet->setPen(row, col, 1, penVert);
     if (penHorz!=penDefault)
       for (row=row1; row<row2; ++row)
         for (col=col1; col<=col2; ++col)
           sheet->setPen(row, col, 0, penHorz);
 
     if (changedBrush)
     {
       for (row=row1; row<=row2; ++row)
         for (col=col1; col<=col2; ++col)
           sheet->setBrush(row, col, brushBackground);
     }
 
     if (changedAlign)
     {
       for (row=row1; row<=row2; ++row)
         for (col=col1; col<=col2; ++col)
           sheet->setTextAlign(row, col, textAlignment);
     }
 
     if (changedFont)
     {
       for (row=row1; row<=row2; ++row)
         for (col=col1; col<=col2; ++col)
           sheet->setTextFont(row, col, fontFont, fontColor);
     }
     return QDialog::Accepted;
   }
   return QDialog::Rejected;
 }
 
 //
 // Border Editor
 //
 
-BorderEditor::BorderEditor(QWidget *parent=0)
+BorderEditor::BorderEditor(QWidget *parent)
              :QFrame(parent)
 {
   setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 }
 
 BorderEditor::~BorderEditor()
 {
 }
 
 void BorderEditor::drawContents(QPainter *p)
 {
   QFrame::drawContents(p);
 
   int x=contentsRect().x(), y=contentsRect().y(), width=contentsRect().width()/3, height=contentsRect().height()/3;
   int lineFirstX=x+width/6, lineFirstY=y+height/6, lineLastX=contentsRect().right()-width/6, lineLastY=contentsRect().bottom()-height/6;
 
   p->fillRect(contentsRect(), Qt::white);
 
   p->fillRect(x+width/3, y+height/3, width, height, Qt::gray);
   p->fillRect(x+(5*width/3), y+height/3, width, height, Qt::gray);
   p->fillRect(x+width/3, y+(5*height)/3, width, height, Qt::gray);
   p->fillRect(x+(5*width)/3, y+(5*height)/3, width, height, Qt::gray);
 
   if (penTop.width()>0)
   {
     p->setPen(penTop);
     p->drawLine(lineFirstX, lineFirstY, lineLastX, lineFirstY);
   }
   if (penBottom.width()>0)
   {
     p->setPen(penBottom);
     p->drawLine(lineFirstX, lineLastY, lineLastX, lineLastY);
   }
   if (penHorz.width()>0)
   {
     p->setPen(penHorz);
     p->drawLine(lineFirstX, y+contentsRect().height()/2, lineLastX, y+contentsRect().height()/2);
   }
   if (penLeft.width()>0)
   {
     p->setPen(penLeft);
     p->drawLine(lineFirstX, lineFirstY, lineFirstX, lineLastY);
   }
   if (penRight.width()>0)
   {
     p->setPen(penRight);
     p->drawLine(lineLastX, lineFirstY, lineLastX, lineLastY);
   }
   if (penVert.width()>0)
   {
     p->setPen(penVert);
     p->drawLine(x+contentsRect().width()/2, lineFirstY, x+contentsRect().width()/2, lineLastY);
   }
 }
 
 void BorderEditor::setPen(const QPen &pen, BorderArea area)
 {
   switch (area)
   {
     case Top: penTop=pen; break;
     case Bottom: penBottom=pen; break;
     case Left: penLeft=pen; break;
     case Right: penRight=pen; break;
     case Horz: penHorz=pen; break;
     case Vert: penVert=pen; break;
   };
   update();
 }
 
 void BorderEditor::mouseReleaseEvent(QMouseEvent *e)
 {
   QFrame::mouseReleaseEvent(e);
 
   int x=contentsRect().x(), y=contentsRect().y(), width=contentsRect().width()/3, height=contentsRect().height()/3;
   BorderArea area=None;
 
   if (e->x()<x+width/3) area=Left;
   if (e->x()>x+(8*width)/3) area=Right;
   if (e->x()>x+(4*width)/3 && e->x()<x+(5*width)/3) area=Vert;
 
   if (e->y()<y+height/3) area=Top;
   if (e->y()>y+(8*height)/3) area=Bottom;
   if (e->y()>y+(4*height)/3 && e->y()<y+(5*height)/3) area=Horz;
 
   if (area!=None)
     emit clicked(area);
 }
 
 QPen BorderEditor::getPen(BorderArea area)
 {
   switch (area)
   {
     case Top: return penTop;
     case Bottom: return penBottom;
     case Left: return penLeft;
     case Right: return penRight;
     case Horz: return penHorz;
     case Vert: return penVert;
   };
   return getDefaultPen();
 }
diff --git a/noncore/apps/opie-sheet/finddlg.cpp b/noncore/apps/opie-sheet/finddlg.cpp
index d1237ca..e4c6ec8 100644
--- a/noncore/apps/opie-sheet/finddlg.cpp
+++ b/noncore/apps/opie-sheet/finddlg.cpp
@@ -1,84 +1,84 @@
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include <qlabel.h>
 #include <qradiobutton.h>
 #include "finddlg.h"
 
-FindDialog::FindDialog(QWidget *parent=0)
+FindDialog::FindDialog(QWidget *parent)
            :QDialog(parent, 0, TRUE)
 {
   // Main widget
   tabs=new QTabWidget(this);
   widgetFind=new QWidget(tabs);
   widgetOptions=new QWidget(tabs);
   tabs->addTab(widgetFind, tr("&Find && Replace"));
   tabs->addTab(widgetOptions, tr("&Options"));
 
   // Find tab
   QLabel *label=new QLabel(tr("&Search for:"), widgetFind);
   label->setGeometry(10, 10, 215, 20);
   editFind=new QLineEdit(widgetFind);
   editFind->setGeometry(10, 40, 215, 20);
   label->setBuddy(editFind);
 
   label=new QLabel(tr("&Replace with:"), widgetFind);
   label->setGeometry(10, 80, 215, 20);
   editReplace=new QLineEdit(widgetFind);
   editReplace->setGeometry(10, 110, 215, 20);
   editReplace->setEnabled(FALSE);
   label->setBuddy(editReplace);
 
   groupType=new QVButtonGroup(tr("&Type"), widgetFind);
   groupType->setGeometry(10, 150, 215, 90);
   QRadioButton *radio=new QRadioButton(tr("&Find"), groupType);
   radio=new QRadioButton(tr("&Replace"), groupType);
   radio=new QRadioButton(tr("Replace &all"), groupType);
   groupType->setButton(0);
   connect(groupType, SIGNAL(clicked(int)), this, SLOT(typeChanged(int)));
 
   // Options tab
   checkCase=new QCheckBox(tr("Match &case"), widgetOptions);
   checkCase->setGeometry(10, 10, 215, 20);
   checkSelection=new QCheckBox(tr("Current &selection only"), widgetOptions);
   checkSelection->setGeometry(10, 40, 215, 20);
   checkEntire=new QCheckBox(tr("&Entire cell"), widgetOptions);
   checkEntire->setGeometry(10, 70, 215, 20);
 
   // Main widget
   box=new QVBoxLayout(this);
   box->addWidget(tabs);
 
   setCaption(tr("Find & Replace"));
 }
 
 FindDialog::~FindDialog()
 {
 }
 
 void FindDialog::typeChanged(int id)
 {
   editReplace->setEnabled(id>0);
 }
 
 int FindDialog::exec(Sheet *s)
 {
   if (QDialog::exec()==QDialog::Accepted)
   {
     int id=groupType->id(groupType->selected());
     s->dataFindReplace(editFind->text(), editReplace->text(), checkCase->isChecked(), !checkSelection->isChecked(), checkEntire->isChecked(), id>0, id>1);
     return QDialog::Accepted;
   }
   return QDialog::Rejected;
 }
diff --git a/noncore/apps/opie-sheet/mainwindow.cpp b/noncore/apps/opie-sheet/mainwindow.cpp
index 09ee68b..2f07bae 100644
--- a/noncore/apps/opie-sheet/mainwindow.cpp
+++ b/noncore/apps/opie-sheet/mainwindow.cpp
@@ -41,257 +41,257 @@
 #include "func-func.xpm"
 #include "func-equal.xpm"
 #include "cell-select.xpm"
 
 #define DEFAULT_NUM_ROWS 199
 #define DEFAULT_NUM_COLS (26*3)
 #define DEFAULT_NUM_SHEETS 3
 
 MainWindow::MainWindow()
            :QMainWindow()
 {
   // initialize variables
   documentModified=FALSE;
 
   // construct objects
   currentDoc=0;
   fileSelector=new FileSelector("application/sheet-qt", this, QString::null);
   connect(fileSelector, SIGNAL(closeMe()), this, SLOT(selectorHide()));
   connect(fileSelector, SIGNAL(newSelected(const DocLnk &)), this, SLOT(selectorFileNew(const DocLnk &)));
   connect(fileSelector, SIGNAL(fileSelected(const DocLnk &)), this, SLOT(selectorFileOpen(const DocLnk &)));
 
   listSheets.setAutoDelete(TRUE);
 
   initActions();
   initMenu();
   initEditToolbar();
   initFunctionsToolbar();
   initStandardToolbar();
   initSheet();
 
   // set window title
   setCaption(tr("Opie Sheet"));
 
   // create sheets
   selectorFileNew(DocLnk());
 }
 
 MainWindow::~MainWindow()
 {
   if (currentDoc) delete currentDoc;
 }
 
 void MainWindow::documentSave(DocLnk *lnkDoc)
 {
   FileManager fm;
   QByteArray streamBuffer;
   QDataStream stream(streamBuffer, IO_WriteOnly);
 
   typeSheet *currentSheet=findSheet(sheet->getName());
   if (!currentSheet)
   {
     QMessageBox::critical(this, tr("Error"), tr("Inconsistency error!"));
     return;
   }
   sheet->copySheetData(&currentSheet->data);
   stream.writeRawBytes("SQT100", 6);
   stream << (Q_UINT32)listSheets.count();
   for (typeSheet *tempSheet=listSheets.first(); tempSheet; tempSheet=listSheets.next())
   {
     stream << tempSheet->name << (Q_UINT32)tempSheet->data.count();
     for (typeCellData *tempCell=tempSheet->data.first(); tempCell; tempCell=tempSheet->data.next())
       stream << (Q_UINT32)tempCell->col << (Q_UINT32)tempCell->row << tempCell->borders.right << tempCell->borders.bottom << tempCell->background << (Q_UINT32)tempCell->alignment << tempCell->fontColor << tempCell->font << tempCell->data;
   }
 
   lnkDoc->setType("application/sheet-qt");
   if (!fm.saveFile(*lnkDoc, streamBuffer))
   {
     QMessageBox::critical(this, tr("Error"), tr("File cannot be saved!"));
     return;
   }
   documentModified=FALSE;
 }
 
 void MainWindow::documentOpen(const DocLnk &lnkDoc)
 {
   FileManager fm;
   QByteArray streamBuffer;
   if (!lnkDoc.isValid() || !fm.loadFile(lnkDoc, streamBuffer))
   {
     QMessageBox::critical(this, tr("Error"), tr("File cannot be opened!"));
     documentModified=FALSE;
     selectorFileNew(DocLnk());
     return;
   }
   QDataStream stream(streamBuffer, IO_ReadOnly);
 
   Q_UINT32 countSheet, countCell, i, j, row, col, alignment;
   typeSheet *newSheet;
   typeCellData *newCell;
 
   char fileFormat[7];
   stream.readRawBytes(fileFormat, 6);
   fileFormat[6]=0;
   if ((QString)fileFormat!="SQT100")
   {
     QMessageBox::critical(this, tr("Error"), tr("Invalid file format!"));
     documentModified=FALSE;
     selectorFileNew(DocLnk());
     return;
   }
 
   stream >> countSheet;
   for (i=0; i<countSheet; ++i)
   {
     newSheet=new typeSheet;
     newSheet->data.setAutoDelete(TRUE);
     stream >> newSheet->name >> countCell;
     comboSheets->insertItem(newSheet->name);
 
     for (j=0; j<countCell; ++j)
     {
       newCell=new typeCellData;
       stream >> col >> row >> newCell->borders.right >> newCell->borders.bottom >> newCell->background >> alignment >> newCell->fontColor >> newCell->font >> newCell->data;
       newCell->col=col;
       newCell->row=row;
       newCell->alignment=(Qt::AlignmentFlags)alignment;
       newSheet->data.append(newCell);
     }
     listSheets.append(newSheet);
 
     if (i==0)
     {
       sheet->setName(newSheet->name);
       sheet->setSheetData(&newSheet->data);
     }
   }
 }
 
-int MainWindow::saveCurrentFile(bool ask=TRUE)
+int MainWindow::saveCurrentFile(bool ask)
 {
   if (ask)
   {
     int result=QMessageBox::information(this, tr("Save File"), tr("Do you want to save the current file?"), QMessageBox::Yes, QMessageBox::No, QMessageBox::Cancel);
     if (result!=QMessageBox::Yes) return result;
   }
 
   if (!currentDoc->isValid())
   {
     TextDialog dialogText(this);
     if (dialogText.exec(tr("Save File"), tr("&File Name:"), tr("UnnamedFile"))!=QDialog::Accepted || dialogText.getValue().isEmpty()) return QMessageBox::Cancel;
 
     currentDoc->setName(dialogText.getValue());
     currentDoc->setFile(QString::null);
     currentDoc->setLinkFile(QString::null);
   }
 
   documentSave(currentDoc);
   return QMessageBox::Yes;
 }
 
 void MainWindow::selectorFileNew(const DocLnk &lnkDoc)
 {
   selectorHide();
 
   if (documentModified && saveCurrentFile()==QMessageBox::Cancel) return;
   if (currentDoc) delete currentDoc;
   currentDoc = new DocLnk(lnkDoc);
   listSheets.clear();
   comboSheets->clear();
 
   typeSheet *newSheet=createNewSheet();
   newSheet->data.setAutoDelete(TRUE);
   sheet->setName(newSheet->name);
   sheet->setSheetData(&newSheet->data);
   for (int i=1; i<DEFAULT_NUM_SHEETS; ++i)
     createNewSheet();
   documentModified=FALSE;
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
   if (documentModified && saveCurrentFile()==QMessageBox::Cancel) e->ignore();
   else e->accept();
 }
 
 void MainWindow::selectorFileOpen(const DocLnk &lnkDoc)
 {
   selectorHide();
 
   if (documentModified && saveCurrentFile()==QMessageBox::Cancel) return;
   if (currentDoc) delete currentDoc;
   currentDoc = new DocLnk(lnkDoc);
   listSheets.clear();
   comboSheets->clear();
 
   documentOpen(lnkDoc);
   documentModified=FALSE;
 }
 
 void MainWindow::selectorShow()
 {
   sheet->hide();
   setCentralWidget(fileSelector);
   fileSelector->show();
   fileSelector->reread();
 }
 
 void MainWindow::selectorHide()
 {
   fileSelector->hide();
   setCentralWidget(sheet);
   sheet->show();
 }
 
 void MainWindow::slotFileNew()
 {
   selectorFileNew(DocLnk());
 }
 
 void MainWindow::slotFileOpen()
 {
   selectorShow();
 }
 
 void MainWindow::slotFileSave()
 {
   saveCurrentFile(FALSE);
 }
 
 void MainWindow::setDocument(const QString &applnk_filename)
 {
   selectorFileOpen(DocLnk(applnk_filename));
 }
 
 void MainWindow::initActions()
 {
   fileNew=new QAction(tr("New File"), QPixmap(file_new_xpm), tr("&New"), 0, this);
   connect(fileNew, SIGNAL(activated()), this, SLOT(slotFileNew()));
   fileOpen=new QAction(tr("Open File"), QPixmap(file_open_xpm), tr("&Open"), 0, this);
   connect(fileOpen, SIGNAL(activated()), this, SLOT(slotFileOpen()));
   fileSave=new QAction(tr("Save File"), QPixmap(file_save_xpm), tr("&Save"), 0, this);
   connect(fileSave, SIGNAL(activated()), this, SLOT(slotFileSave()));
   fileSaveAs=new QAction(tr("Save File As"), QPixmap(file_save_xpm), tr("Save &As"), 0, this);
   connect(fileSaveAs, SIGNAL(activated()), this, SLOT(slotFileSaveAs()));
   fileQuit=new QAction(tr("Quit"), tr("&Quit"), 0, this);
   connect(fileQuit, SIGNAL(activated()), this, SLOT(close()));
 
   helpGeneral=new QAction(tr("General Help"), QPixmap(help_general_xpm), tr("&General"), 0, this);
   connect(helpGeneral, SIGNAL(activated()), this, SLOT(slotHelpGeneral()));
   helpAbout=new QAction(tr("About Opie Sheet"), tr("&About"), 0, this);
   connect(helpAbout, SIGNAL(activated()), this, SLOT(slotHelpAbout()));
 
   editAccept=new QAction(tr("Accept"), QPixmap(edit_accept_xpm), tr("&Accept"), 0, this);
   connect(editAccept, SIGNAL(activated()), this, SLOT(slotEditAccept()));
   editCancel=new QAction(tr("Cancel"), QPixmap(edit_cancel_xpm), tr("&Cancel"), 0, this);
   connect(editCancel, SIGNAL(activated()), this, SLOT(slotEditCancel()));
   editCellSelect=new QAction(tr("Cell Selector"), QPixmap(cell_select_xpm), tr("Cell &Selector"), 0, this);
   editCellSelect->setToggleAction(TRUE);
   connect(editCellSelect, SIGNAL(toggled(bool)), this, SLOT(slotCellSelect(bool)));
   editCut=new QAction(tr("Cut Cells"), tr("Cu&t"), 0, this);
   editCopy=new QAction(tr("Copy Cells"), tr("&Copy"), 0, this);
   editPaste=new QAction(tr("Paste Cells"), tr("&Paste"), 0, this);
   connect(editPaste, SIGNAL(activated()), this, SLOT(slotEditPaste()));
   editPasteContents=new QAction(tr("Paste Contents"), tr("Paste Cont&ents"), 0, this);
   connect(editPasteContents, SIGNAL(activated()), this, SLOT(slotEditPasteContents()));
   editClear=new QAction(tr("Clear Cells"), tr("C&lear"), 0, this);
 
diff --git a/noncore/apps/opie-sheet/numberdlg.cpp b/noncore/apps/opie-sheet/numberdlg.cpp
index e8de639..90fbaa2 100644
--- a/noncore/apps/opie-sheet/numberdlg.cpp
+++ b/noncore/apps/opie-sheet/numberdlg.cpp
@@ -1,49 +1,50 @@
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include "numberdlg.h"
 
-NumberDialog::NumberDialog(QWidget *parent=0)
+NumberDialog::NumberDialog(QWidget *parent)
              :QDialog(parent, 0, TRUE)
 {
   edit=new QSpinBox(this);
   edit->setGeometry(120, 10, 70, 25);
 
   label=new QLabel(this);
   label->setGeometry(10, 10, 100, 25);
   label->setBuddy(edit);
 
   resize(200, 45);
 }
 
 NumberDialog::~NumberDialog()
 {
 }
 
-int NumberDialog::exec(const QString &caption, const QString &text, int value=1, int min=1, int max=99, int step=1)
+int NumberDialog::exec(const QString &caption, const QString &text,
+                       int value, int min, int max, int step)
 {
   setCaption(caption);
   label->setText(text);
   edit->setValue(value);
   edit->setMinValue(min);
   edit->setMaxValue(max);
   edit->setLineStep(step);
 
   return QDialog::exec();
 }
 
 int NumberDialog::getValue()
 {
   return edit->value();
 }
diff --git a/noncore/apps/opie-sheet/sheet.cpp b/noncore/apps/opie-sheet/sheet.cpp
index 1d7ec6f..2279191 100644
--- a/noncore/apps/opie-sheet/sheet.cpp
+++ b/noncore/apps/opie-sheet/sheet.cpp
@@ -1,276 +1,276 @@
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include "sheet.h"
 
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <math.h>
 
 #define DEFAULT_COL_WIDTH 50
 
 Sheet::Sheet(int numRows, int numCols, QWidget *parent)
       :QTable(numRows, numCols, parent)
 {
   defaultBorders.right=defaultBorders.bottom=QPen(Qt::gray, 1, Qt::SolidLine);
   defaultCellData.data="";
   defaultCellData.background=QBrush(Qt::white, Qt::SolidPattern);
   defaultCellData.alignment=(Qt::AlignmentFlags)(Qt::AlignLeft | Qt::AlignTop);
   defaultCellData.fontColor=Qt::black;
   defaultCellData.font=font();
   defaultCellData.borders=defaultBorders;
 
   selectionNo=-1;
   setSelectionMode(QTable::Single);
 
   sheetData.setAutoDelete(TRUE);
   clipboardData.setAutoDelete(TRUE);
   for (int i=0; i<numCols; ++i)
     horizontalHeader()->setLabel(i, getHeaderString(i+1), DEFAULT_COL_WIDTH);
 
   connect(this, SIGNAL(currentChanged(int, int)), this, SLOT(slotCellSelected(int, int)));
   connect(this, SIGNAL(valueChanged(int, int)), this, SLOT(slotCellChanged(int, int)));
 }
 
 Sheet::~Sheet()
 {
 }
 
 typeCellData *Sheet::findCellData(int row, int col)
 {
   typeCellData *tempCellData;
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
     if (tempCellData->row==row && tempCellData->col==col)
       return tempCellData;
   return NULL;
 }
 
 void Sheet::slotCellSelected(int row, int col)
 {
   typeCellData *cellData=findCellData(row, col);
   if (cellData)
     emit currentDataChanged(cellData->data);
   else
     emit currentDataChanged("");
 }
 
 typeCellData *Sheet::createCellData(int row, int col)
 {
   if (row<0 || col<0) return NULL;
   typeCellData *cellData=new typeCellData;
   cellData->row=row;
   cellData->col=col;
   cellData->data=defaultCellData.data;
   cellData->borders=defaultCellData.borders;
   cellData->alignment=defaultCellData.alignment;
   cellData->font=defaultCellData.font;
   cellData->fontColor=defaultCellData.fontColor;
   cellData->background=defaultCellData.background;
   sheetData.append(cellData);
   return cellData;
 }
 
 void Sheet::slotCellChanged(int row, int col)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=createCellData(row, col);
   if (cellData) cellData->data=text(row, col);
   for (cellData=sheetData.first(); cellData; cellData=sheetData.next())
     setText(cellData->row, cellData->col, dataParser(cellData->data));
   emit sheetModified();
 }
 
 void Sheet::swapCells(int row1, int col1, int row2, int col2)
 {
   typeCellData *cellData1=findCellData(row1, col1), *cellData2=findCellData(row2, col2);
   if (!cellData1) cellData1=createCellData(row1, col1);
   if (!cellData2) cellData2=createCellData(row2, col2);
   if (cellData1 && cellData2)
   {
     QString tempData(cellData1->data);
     cellData1->data=cellData2->data;
     cellData2->data=tempData;
     setText(cellData1->row, cellData1->col, dataParser(cellData1->data));
     setText(cellData2->row, cellData2->col, dataParser(cellData2->data));
     emit sheetModified();
   }
 }
 
-QString Sheet::getParameter(const QString &parameters, int paramNo, bool giveError=FALSE, const QString funcName="")
+QString Sheet::getParameter(const QString &parameters, int paramNo, bool giveError, const QString funcName)
 {
   QString params(parameters);
   int position;
   for (int i=0; i<paramNo; ++i)
   {
     position=params.find(',');
     if (position<0)
     {
       if (giveError) QMessageBox::critical(this, tr("Error"), tr("Too few arguments to function '"+funcName+'\''));
       return QString();
     }
     params=params.mid(position+1);
   }
   position=params.find(',');
   if (position<0) return params;
   return params.left(position);
 }
 
 bool Sheet::findRange(const QString &variable1, const QString &variable2, int *row1, int *col1, int *row2, int *col2)
 {
   int row, col;
   if (!findRowColumn(variable1, row1, col1, TRUE) || !findRowColumn(variable2, row2, col2, TRUE)) return FALSE;
   if (*row1>*row2)
   {
     row=*row1;
     *row1=*row2;
     *row2=row;
   }
   if (*col1>*col2)
   {
     col=*col1;
     *col1=*col2;
     *col2=col;
   }
   return TRUE;
 }
 
-bool Sheet::findRowColumn(const QString &variable, int *row, int *col, bool giveError=FALSE)
+bool Sheet::findRowColumn(const QString &variable, int *row, int *col, bool giveError)
 {
   int position=variable.find(QRegExp("\\d"));
   if (position<1)
   {
     if (giveError) QMessageBox::critical(this, tr("Error"), tr("Invalid variable: '"+variable+'\''));
     return FALSE;
   }
   *row=variable.mid(position).toInt()-1;
   *col=getHeaderColumn(variable.left(position))-1;
   return TRUE;
 }
 
 double Sheet::calculateVariable(const QString &variable)
 {
   bool ok;
   double tempResult=variable.toDouble(&ok);
   if (ok) return tempResult;
 
   int row, col;
   return (findRowColumn(variable, &row, &col, TRUE) ? text(row, col).toDouble() : 0);
 }
 
 double Sheet::functionSum(const QString &param1, const QString &param2)
 {
   int row1, col1, row2, col2, row, col;
   if (!findRange(param1, param2, &row1, &col1, &row2, &col2)) return 0;
 
   double result=0, tempResult;
   bool ok;
   for (row=row1; row<=row2; ++row)
     for (col=col1; col<=col2; ++col)
     {
       tempResult=text(row, col).toDouble(&ok);
       if (ok) result+=tempResult;
     }
 
   return result;
 }
 
 double Sheet::functionMin(const QString &param1, const QString &param2)
 {
   int row1, col1, row2, col2, row, col;
   if (!findRange(param1, param2, &row1, &col1, &row2, &col2)) return 0;
 
   double min=0, tempMin;
   bool ok, init=FALSE;
   for (row=row1; row<=row2; ++row)
     for (col=col1; col<=col2; ++col)
     {
       tempMin=text(row, col).toDouble(&ok);
       if (ok && (!init || tempMin<min))
       {
         min=tempMin;
         init=TRUE;
       }
     }
 
   return min;
 }
 
 double Sheet::functionMax(const QString &param1, const QString &param2)
 {
   int row1, col1, row2, col2, row, col;
   if (!findRange(param1, param2, &row1, &col1, &row2, &col2)) return 0;
 
   double max=0, tempMax;
   bool ok, init=FALSE;
   for (row=row1; row<=row2; ++row)
     for (col=col1; col<=col2; ++col)
     {
       tempMax=text(row, col).toDouble(&ok);
       if (ok && (!init || tempMax>max))
       {
         max=tempMax;
         init=TRUE;
       }
     }
 
   return max;
 }
 
 double Sheet::functionAvg(const QString &param1, const QString &param2)
 {
   double resultSum=functionSum(param1, param2), resultCount=functionCount(param1, param2);
   return (resultCount>0 ? resultSum/resultCount : 0);
 }
 
 double Sheet::functionCount(const QString &param1, const QString &param2)
 {
   int row1, col1, row2, col2, row, col;
   if (!findRange(param1, param2, &row1, &col1, &row2, &col2)) return 0;
 
   int divider=0;
   bool ok;
   for (row=row1; row<=row2; ++row)
     for (col=col1; col<=col2; ++col)
     {
       text(row, col).toDouble(&ok);
       if (ok) ++divider;
     }
 
   return divider;
 }
 
 double Sheet::calculateFunction(const QString &function, const QString &parameters)
 {
   if (function=="+")
     return calculateVariable(getParameter(parameters, 0))+calculateVariable(getParameter(parameters, 1));
   if (function=="-")
     return calculateVariable(getParameter(parameters, 0))-calculateVariable(getParameter(parameters, 1));
   if (function=="*")
     return calculateVariable(getParameter(parameters, 0))*calculateVariable(getParameter(parameters, 1));
   if (function=="/")
     return calculateVariable(getParameter(parameters, 0))/calculateVariable(getParameter(parameters, 1));
   if (function=="SUM")
     return functionSum(getParameter(parameters, 0, TRUE, function), getParameter(parameters, 1, TRUE, function));
   if (function=="COUNT")
     return functionCount(getParameter(parameters, 0, TRUE, function), getParameter(parameters, 1, TRUE, function));
   if (function=="MIN")
     return functionMin(getParameter(parameters, 0, TRUE, function), getParameter(parameters, 1, TRUE, function));
   if (function=="MAX")
     return functionMax(getParameter(parameters, 0, TRUE, function), getParameter(parameters, 1, TRUE, function));
   if (function=="AVG")
     return functionAvg(getParameter(parameters, 0, TRUE, function), getParameter(parameters, 1, TRUE, function));
   if (function=="ABS")
     return fabs(calculateVariable(getParameter(parameters, 0, TRUE, function)));
   if (function=="SIN")
     return sin(calculateVariable(getParameter(parameters, 0, TRUE, function)));
@@ -327,257 +327,257 @@ QChar Sheet::popCharStack(QStack<QChar> *stackChars)
   if (stackChars->isEmpty())
   {
     QMessageBox::critical(this, tr("Error"), tr("Syntax error!"));
     return '0';
   }
 
   QChar *temp=stackChars->pop();
   QChar temp2(*temp);
   delete temp;
   return temp2;
 }
 
 QString Sheet::popStringStack(QStack<QString> *stackStrings)
 {
   if (stackStrings->isEmpty())
   {
     QMessageBox::critical(this, tr("Error"), tr("Syntax error!"));
     return "0";
   }
 
   QString *temp=stackStrings->pop();
   QString temp2(*temp);
   delete temp;
   return temp2;
 }
 
 QString Sheet::dataParserHelper(const QString &data)
 {
   QStack<QString> stackElements;
   QStack<QChar> stackOperators;
   QString tempElement(""), temp2Element, firstElement, secondElement;
   int paranCount;
 
   for (unsigned int i=0; i<data.length(); ++i)
   {
     if (data[i]=='+' || data[i]=='-' || data[i]=='*' || data[i]=='/')
     {
       pushStringStack(&stackElements, tempElement);
       tempElement="";
       if (!stackOperators.isEmpty() && getOperatorPriority(*stackOperators.top())>getOperatorPriority(data[i]))
       {
         secondElement=popStringStack(&stackElements);
         firstElement=popStringStack(&stackElements);
         pushStringStack(&stackElements, QString::number(calculateFunction(popCharStack(&stackOperators), firstElement+","+secondElement)));
       }
       pushCharStack(&stackOperators, data[i]);
     }
     else
     if (data[i]==',')
     {
       if (!tempElement.isEmpty()) pushStringStack(&stackElements, tempElement);
       while (!stackOperators.isEmpty())
       {
         secondElement=popStringStack(&stackElements);
         firstElement=popStringStack(&stackElements);
         pushStringStack(&stackElements, QString::number(calculateFunction(popCharStack(&stackOperators), firstElement+","+secondElement)));
       }
       tempElement="";
     }
     else
     if (data[i]=='(')
     {
       paranCount=1;
       temp2Element="";
       for (++i; paranCount>0; ++i)
       {
         temp2Element+=data[i];
         if (data[i]=='(') ++paranCount;
         if (data[i]==')') --paranCount;
       }
       temp2Element=dataParserHelper(temp2Element.left(temp2Element.length()-1));
       if (tempElement.isEmpty())
         tempElement=temp2Element;
       else
         tempElement.setNum(calculateFunction(tempElement, temp2Element));
       --i;
     }
     else
       tempElement+=data[i];
   }
   if (!tempElement.isEmpty()) pushStringStack(&stackElements, tempElement);
   while (!stackOperators.isEmpty())
   {
     secondElement=popStringStack(&stackElements);
     firstElement=popStringStack(&stackElements);
     pushStringStack(&stackElements, QString::number(calculateFunction(popCharStack(&stackOperators), firstElement+","+secondElement)));
   }
 
   if (!stackElements.isEmpty())
     tempElement=popStringStack(&stackElements);
   while (!stackElements.isEmpty())
     tempElement.prepend(popStringStack(&stackElements)+",");
   return tempElement;
 }
 
 QString Sheet::dataParser(const QString &data)
 {
   QString strippedData(data);
   strippedData.replace(QRegExp("\\s"), "");
   if (strippedData.isEmpty() || strippedData[0]!='=') return data;
   strippedData=dataParserHelper(strippedData.remove(0, 1).upper().replace(QRegExp(":"), ","));
 
   int i=0;
   QString tempParameter(getParameter(strippedData, i)), result="";
   do
   {
     result+=","+QString::number(calculateVariable(tempParameter));
     tempParameter=getParameter(strippedData, ++i);
   }
   while (!tempParameter.isNull());
   return result.mid(1);
 }
 
 void Sheet::setData(const QString &data)
 {
   setText(currentRow(), currentColumn(), data);
   slotCellChanged(currentRow(), currentColumn());
   activateNextCell();
 }
 
 QString Sheet::getData()
 {
   typeCellData *cellData=findCellData(currentRow(), currentColumn());
   if (cellData)
     return cellData->data;
   return "";
 }
 
-void Sheet::lockClicks(bool lock=TRUE)
+void Sheet::lockClicks(bool lock)
 {
   clicksLocked=lock;
 }
 
 void Sheet::paintCell(QPainter *p, int row, int col, const QRect & cr, bool selected)
 {
   if (selected && row==currentRow() && col==currentColumn()) selected=FALSE;
 
   int sheetDataCurrent=sheetData.at();
   typeCellData *cellData=findCellData(row, col);
   if (sheetDataCurrent>=0) sheetData.at(sheetDataCurrent);
   if (!cellData) cellData=&defaultCellData;
   if (selected)
     p->fillRect(0, 0, cr.width(), cr.height(), colorGroup().highlight());
   else
   {
     p->fillRect(0, 0, cr.width(), cr.height(), colorGroup().base());
     p->fillRect(0, 0, cr.width(), cr.height(), cellData->background);
   }
 
   QTableItem *cellItem=item(row, col);
   if (cellItem)
   {
     p->setPen(selected ? colorGroup().highlightedText() : cellData->fontColor);
     p->setFont(cellData->font);
     p->drawText(2, 2, cr.width()-4, cr.height()-4, cellData->alignment, cellItem->text());
   }
 
   int rx=cr.width()-1, ry=cr.height()-1;
   QPen pen(p->pen());
   p->setPen(cellData->borders.right);
   p->drawLine(rx, 0, rx, ry);
   p->setPen(cellData->borders.bottom);
   p->drawLine(0, ry, rx, ry);
   p->setPen(pen);
 }
 
 void Sheet::viewportMousePressEvent(QMouseEvent *e)
 {
   QMouseEvent ce(e->type(), viewportToContents(e->pos()), e->globalPos(), e->button(), e->state());
   if (clicksLocked)
   {
     if (selectionNo<0)
     {
       clearSelection();
       QTableSelection newSelection;
       newSelection.init(rowAt(ce.pos().y()), columnAt(ce.pos().x()));
       newSelection.expandTo(newSelection.anchorRow(), newSelection.anchorCol());
       selectionNo=addSelection(newSelection);
     }
   }
   else
     QTable::contentsMousePressEvent(&ce);
 }
 
 void Sheet::viewportMouseMoveEvent(QMouseEvent *e)
 {
   QMouseEvent ce(e->type(), viewportToContents(e->pos()), e->globalPos(), e->button(), e->state());
   if (clicksLocked)
   {
     if (selectionNo>=0)
     {
       QTableSelection oldSelection(selection(selectionNo));
       oldSelection.expandTo(rowAt(ce.pos().y()), columnAt(ce.pos().x()));
       if (!(oldSelection==selection(selectionNo)))
       {
         removeSelection(selectionNo);
         selectionNo=addSelection(oldSelection);
       }
     }
   }
   else
     QTable::contentsMouseMoveEvent(&ce);
 }
 
 void Sheet::viewportMouseReleaseEvent(QMouseEvent *e)
 {
   QMouseEvent ce(e->type(), viewportToContents(e->pos()), e->globalPos(), e->button(), e->state());
   if (clicksLocked && selectionNo>=0)
   {
     QTableSelection oldSelection(selection(selectionNo));
     oldSelection.expandTo(rowAt(ce.pos().y()), columnAt(ce.pos().x()));
     removeSelection(selectionNo);
     selectionNo=-1;
     if (oldSelection.topRow()==oldSelection.bottomRow() && oldSelection.leftCol()==oldSelection.rightCol())
       emit cellClicked(getHeaderString(oldSelection.leftCol()+1)+QString::number(oldSelection.topRow()+1));
     else
       emit cellClicked(getHeaderString(oldSelection.leftCol()+1)+QString::number(oldSelection.topRow()+1)+','+getHeaderString(oldSelection.rightCol()+1)+QString::number(oldSelection.bottomRow()+1));
   }
   else
     QTable::contentsMouseReleaseEvent(&ce);
 }
 
 void Sheet::copySheetData(QList<typeCellData> *destSheetData)
 {
   typeCellData *tempCellData, *newCellData;
   destSheetData->clear();
 
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
   {
     newCellData=new typeCellData;
     *newCellData=*tempCellData;
     destSheetData->append(newCellData);
   }
 }
 
 void Sheet::setSheetData(QList<typeCellData> *srcSheetData)
 {
   typeCellData *tempCellData, *newCellData;
 
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
   {
     clearCell(tempCellData->row, tempCellData->col);
     updateCell(tempCellData->row, tempCellData->col);
   }
   sheetData.clear();
 
   for (tempCellData=srcSheetData->first(); tempCellData; tempCellData=srcSheetData->next())
   {
     newCellData=new typeCellData;
     *newCellData=*tempCellData;
     sheetData.append(newCellData);
     setText(newCellData->row, newCellData->col, dataParser(newCellData->data));
   }
   emit sheetModified();
 }
 
 void Sheet::setName(const QString &name)
@@ -611,253 +611,253 @@ QBrush Sheet::getBrush(int row, int col)
 
 void Sheet::setTextAlign(int row, int col, Qt::AlignmentFlags flags)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=createCellData(row, col);
   if (cellData)
   {
     cellData->alignment=flags;
     emit sheetModified();
   }
 }
 
 Qt::AlignmentFlags Sheet::getAlignment(int row, int col)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=&defaultCellData;
   return cellData->alignment;
 }
 
 void Sheet::setTextFont(int row, int col, const QFont &font, const QColor &color)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=createCellData(row, col);
   if (cellData)
   {
     cellData->font=font;
     cellData->fontColor=color;
     emit sheetModified();
   }
 }
 
 QFont Sheet::getFont(int row, int col)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=&defaultCellData;
   return cellData->font;
 }
 
 QColor Sheet::getFontColor(int row, int col)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=&defaultCellData;
   return cellData->fontColor;
 }
 
 void Sheet::setPen(int row, int col, int vertical, const QPen &pen)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=createCellData(row, col);
   if (cellData)
   {
     if (vertical)
       cellData->borders.right=pen;
     else
       cellData->borders.bottom=pen;
     emit sheetModified();
   }
 }
 
 QPen Sheet::getPen(int row, int col, int vertical)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=&defaultCellData;
   return (vertical ? cellData->borders.right : cellData->borders.bottom);
 }
 
 void Sheet::getSelection(int *row1, int *col1, int *row2, int *col2)
 {
   int selectionNo=currentSelection();
   if (selectionNo>=0)
   {
     QTableSelection selection(selection(selectionNo));
     *row1=selection.topRow();
     *row2=selection.bottomRow();
     *col1=selection.leftCol();
     *col2=selection.rightCol();
   }
   else
   {
     *row1=*row2=currentRow();
     *col1=*col2=currentColumn();
   }
 }
 
 void Sheet::editClear()
 {
   int row1, row2, col1, col2;
   getSelection(&row1, &col1, &row2, &col2);
 
   int row, col;
   for (row=row1; row<=row2; ++row)
     for (col=col1; col<=col2; ++col)
     {
       setText(row, col, "");
       slotCellChanged(row, col);
     }
 }
 
 void Sheet::editCopy()
 {
   clipboardData.clear();
 
   int row1, row2, col1, col2;
   getSelection(&row1, &col1, &row2, &col2);
 
   typeCellData *cellData, *newCellData;
   int row, col;
   for (row=row1; row<=row2; ++row)
     for (col=col1; col<=col2; ++col)
     {
       cellData=findCellData(row, col);
       if (cellData)
       {
         newCellData=new typeCellData;
         *newCellData=*cellData;
         newCellData->row-=row1;
         newCellData->col-=col1;
         clipboardData.append(newCellData);
       }
     }
 }
 
 void Sheet::editCut()
 {
   editCopy();
   editClear();
 }
 
-void Sheet::editPaste(bool onlyContents=FALSE)
+void Sheet::editPaste(bool onlyContents)
 {
   int row1=currentRow(), col1=currentColumn();
   typeCellData *cellData, *tempCellData;
 
   for (tempCellData=clipboardData.first(); tempCellData; tempCellData=clipboardData.next())
   {
     cellData=findCellData(tempCellData->row+row1, tempCellData->col+col1);
     if (!cellData) cellData=createCellData(tempCellData->row+row1, tempCellData->col+col1);
     if (cellData)
     {
       if (onlyContents)
         cellData->data=tempCellData->data;
       else
       {
         *cellData=*tempCellData;
         cellData->row+=row1;
         cellData->col+=col1;
       }
       setText(cellData->row, cellData->col, dataParser(cellData->data));
       emit sheetModified();
     }
   }
 }
 
-void Sheet::insertRows(int no=1, bool allColumns=TRUE)
+void Sheet::insertRows(int no, bool allColumns)
 {
   setNumRows(numRows()+no);
 
   typeCellData *tempCellData;
   int row=currentRow(), col=currentColumn();
 
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
     if (tempCellData->row>=row && (allColumns || tempCellData->col==col))
     {
       clearCell(tempCellData->row, tempCellData->col);
       tempCellData->row+=no;
     }
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
     if (tempCellData->row>=row && (allColumns || tempCellData->col==col))
     {
       updateCell(tempCellData->row-no, tempCellData->col);
       setText(tempCellData->row, tempCellData->col, dataParser(tempCellData->data));
     }
  emit sheetModified();
 }
 
-void Sheet::insertColumns(int no=1, bool allRows=TRUE)
+void Sheet::insertColumns(int no, bool allRows)
 {
   int noCols=numCols();
   int newCols=noCols+no;
   setNumCols(newCols);
   for (int i=noCols; i<newCols; ++i)
     horizontalHeader()->setLabel(i, getHeaderString(i+1), DEFAULT_COL_WIDTH);
 
   typeCellData *tempCellData;
   int col=currentColumn(), row=currentRow();
 
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
     if (tempCellData->col>=col && (allRows || tempCellData->row==row))
     {
       clearCell(tempCellData->row, tempCellData->col);
       tempCellData->col+=no;
     }
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
     if (tempCellData->col>=col && (allRows || tempCellData->row==row))
     {
       updateCell(tempCellData->row, tempCellData->col-no);
       setText(tempCellData->row, tempCellData->col, dataParser(tempCellData->data));
     }
   emit sheetModified();
 }
 
-void Sheet::dataFindReplace(const QString &findStr, const QString &replaceStr, bool matchCase=TRUE, bool allCells=TRUE, bool entireCell=FALSE, bool replace=FALSE, bool replaceAll=FALSE)
+void Sheet::dataFindReplace(const QString &findStr, const QString &replaceStr, bool matchCase, bool allCells, bool entireCell, bool replace, bool replaceAll)
 {
   typeCellData *tempCellData;
   int row1, col1, row2, col2;
   getSelection(&row1, &col1, &row2, &col2);
   bool found=FALSE;
 
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
     if (allCells || (tempCellData->row>=row1 && tempCellData->row<=row2 && tempCellData->col>=col1 && tempCellData->col<=col2))
     {
       QTableItem *cellItem=item(tempCellData->row, tempCellData->col);
       if (cellItem && (entireCell ? (matchCase ? cellItem->text()==findStr : cellItem->text().upper()==findStr.upper()) : cellItem->text().find(findStr, 0, matchCase)>=0))
       {
         if (!found)
         {
           found=TRUE;
           clearSelection();
         }
         setCurrentCell(tempCellData->row, tempCellData->col);
         if (replace)
         {
           tempCellData->data=cellItem->text().replace(QRegExp(findStr, matchCase), replaceStr);
           setText(tempCellData->row, tempCellData->col, dataParser(tempCellData->data));
         }
         if (!replace || !replaceAll) break;
       }
     }
 
  if (found)
  {
    if (replace)
      slotCellChanged(currentRow(), currentColumn());
  }
  else
    QMessageBox::warning(this, tr("Error"), tr("Search key not found!"));
 }
 
 //
 // Static functions
 //
 
 QString Sheet::getHeaderString(int section)
 {
   if (section<1) return "";
   return getHeaderString((section-1)/26)+QChar('A'+(section-1)%26);
 }
 
 int Sheet::getHeaderColumn(const QString &section)
 {
   if (section.isEmpty()) return 0;
   return (section[section.length()-1]-'A'+1)+getHeaderColumn(section.left(section.length()-1))*26;
 }
diff --git a/noncore/apps/opie-sheet/sortdlg.cpp b/noncore/apps/opie-sheet/sortdlg.cpp
index c60be0d..c2cdec8 100644
--- a/noncore/apps/opie-sheet/sortdlg.cpp
+++ b/noncore/apps/opie-sheet/sortdlg.cpp
@@ -1,192 +1,193 @@
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include <qlabel.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 #include "sortdlg.h"
 
-SortDialog::SortDialog(QWidget *parent=0)
+SortDialog::SortDialog(QWidget *parent)
            :QDialog(parent, 0, TRUE)
 {
   // Main widget
   tabs=new QTabWidget(this);
   widgetSort=new QWidget(tabs);
   widgetOptions=new QWidget(tabs);
   tabs->addTab(widgetSort, tr("&Sort"));
   tabs->addTab(widgetOptions, tr("&Options"));
 
   // Sort tab
   comboFieldA=createFieldCombo(tr("&Sort by"), 10);
   groupOrderA=createOrderButtons(10);
   comboFieldB=createFieldCombo(tr("&Then by"), 90);
   groupOrderB=createOrderButtons(90);
   comboFieldC=createFieldCombo(tr("Then &by"), 170);
   groupOrderC=createOrderButtons(170);
 
   // Options tab
   checkCase=new QCheckBox(tr("&Case Sensitive"), widgetOptions);
   checkCase->setGeometry(10, 10, 215, 20);
   checkCase->setChecked(TRUE);
 
   groupDirection=new QVButtonGroup(tr("&Direction"), widgetOptions);
   groupDirection->setGeometry(10, 40, 215, 70);
   QRadioButton *radio=new QRadioButton(tr("&Top to bottom (rows)"), groupDirection);
   radio=new QRadioButton(tr("&Left to right (columns)"), groupDirection);
   groupDirection->setButton(0);
   connect(groupDirection, SIGNAL(clicked(int)), this, SLOT(directionChanged(int)));
 
   // Main widget
   box=new QVBoxLayout(this);
   box->addWidget(tabs);
 
   setCaption(tr("Sort"));
 }
 
 SortDialog::~SortDialog()
 {
 }
 
 QComboBox *SortDialog::createFieldCombo(const QString &caption, int y)
 {
   QLabel *label=new QLabel(caption, widgetSort);
   label->setGeometry(10, y+5, 215, 20);
   QComboBox *combo=new QComboBox(FALSE, widgetSort);
   combo->setGeometry(10, y+35, 105, 20);
   label->setBuddy(combo);
   return combo;
 }
 
 QVButtonGroup *SortDialog::createOrderButtons(int y)
 {
   QVButtonGroup *group=new QVButtonGroup(widgetSort);
   group->setGeometry(125, y, 100, 60);
   QRadioButton *radio=new QRadioButton(tr("&Ascending"), group);
   radio=new QRadioButton(tr("&Descending"), group);
   group->setButton(0);
   return group;
 }
 
 void SortDialog::directionChanged(int id)
 {
   direction=id;
   fillFieldCombo(comboFieldA);
   fillFieldCombo(comboFieldB);
   fillFieldCombo(comboFieldC);
 }
 
 void SortDialog::fillFieldCombo(QComboBox *combo)
 {
   combo->clear();
   if (direction)
     for (int row=row1; row<=row2; ++row)
       combo->insertItem("Row "+QString::number(row+1));
   else
     for (int col=col1; col<=col2; ++col)
       combo->insertItem("Column "+Sheet::getHeaderString(col+1));
 }
 
 int SortDialog::exec(Sheet *s)
 {
   sheet=s;
   sheet->getSelection(&row1, &col1, &row2, &col2);
 
   direction=0;
   fillFieldCombo(comboFieldA);
   fillFieldCombo(comboFieldB);
   fillFieldCombo(comboFieldC);
 
   if (row1==row2 && col1==col2)
   {
     QMessageBox::warning(this, tr("Error"), tr("One cell cannot be sorted!"));
     return QDialog::Rejected;
   }
   if (QDialog::exec()==QDialog::Accepted)
   {
     QString field1S=comboFieldA->currentText(), field2S=comboFieldB->currentText(), field3S=comboFieldC->currentText();
     field1S=field1S.mid(field1S.find(' ')+1);
     field2S=field2S.mid(field2S.find(' ')+1);
     field3S=field3S.mid(field3S.find(' ')+1);
     int field1, field2, field3;
     if (direction)
     {
       field1=field1S.toInt()-1;
       field2=field2S.toInt()-1;
       field3=field3S.toInt()-1;
       int i, j;
       for (i=col2; i>=col1; --i)
         for (j=col1+1; j<=i; ++j)
         {
           bool swap=FALSE;
           int compareResult=compareItems(s->item(field1, j-1), s->item(field1, j), groupOrderA->id(groupOrderA->selected()), checkCase->isChecked());
           if (compareResult>0) swap=TRUE;
           else if (compareResult==0)
           {
             compareResult=compareItems(s->item(field2, j-1), s->item(field2, j), groupOrderB->id(groupOrderB->selected()), checkCase->isChecked());
             if (compareResult>0) swap=TRUE;
             else if (compareResult==0)
             {
               compareResult=compareItems(s->item(field3, j-1), s->item(field3, j), groupOrderC->id(groupOrderC->selected()), checkCase->isChecked());
               if (compareResult>0) swap=TRUE;
             }
           }
           if (swap)
             for (int row=row1; row<=row2; ++row)
               s->swapCells(row, j-1, row, j);
         }
     }
     else
     {
       field1=Sheet::getHeaderColumn(field1S)-1;
       field2=Sheet::getHeaderColumn(field2S)-1;
       field3=Sheet::getHeaderColumn(field3S)-1;
       int i, j;
       for (i=row2; i>=row1; --i)
         for (j=row1+1; j<=i; ++j)
         {
           bool swap=FALSE;
           int compareResult=compareItems(s->item(j-1, field1), s->item(j, field1), groupOrderA->id(groupOrderA->selected()), checkCase->isChecked());
           if (compareResult>0) swap=TRUE;
           else if (compareResult==0)
           {
             compareResult=compareItems(s->item(j-1, field2), s->item(j, field2), groupOrderB->id(groupOrderB->selected()), checkCase->isChecked());
             if (compareResult>0) swap=TRUE;
             else if (compareResult==0)
             {
               compareResult=compareItems(s->item(j-1, field3), s->item(j, field3), groupOrderC->id(groupOrderC->selected()), checkCase->isChecked());
               if (compareResult>0) swap=TRUE;
             }
           }
           if (swap)
             for (int col=col1; col<=col2; ++col)
               s->swapCells(j-1, col, j, col);
         }
     }
     return QDialog::Accepted;
   }
   return QDialog::Rejected;
 }
 
-int SortDialog::compareItems(QTableItem *item1, QTableItem *item2, int descending=0, bool caseSensitive=TRUE)
+int SortDialog::compareItems(QTableItem *item1, QTableItem *item2,
+                             int descending, bool caseSensitive)
 {
   int result=0;
   if (item1)
   {
     if (item2) result=(caseSensitive ? item1->text().compare(item2->text()) : item1->text().upper().compare(item2->text().upper()));
     else result=-1;
   }
   else
     if (item2) result=1;
   return (descending ? -result : result);
 }
diff --git a/noncore/apps/opie-sheet/textdlg.cpp b/noncore/apps/opie-sheet/textdlg.cpp
index 0810eb2..34cec29 100644
--- a/noncore/apps/opie-sheet/textdlg.cpp
+++ b/noncore/apps/opie-sheet/textdlg.cpp
@@ -1,46 +1,47 @@
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include "textdlg.h"
 
-TextDialog::TextDialog(QWidget *parent=0)
+TextDialog::TextDialog(QWidget *parent)
            :QDialog(parent, 0, TRUE)
 {
   edit=new QLineEdit(this);
   edit->setGeometry(90, 10, 100, 25);
 
   label=new QLabel(this);
   label->setGeometry(10, 10, 70, 25);
   label->setBuddy(edit);
 
   resize(200, 45);
 }
 
 TextDialog::~TextDialog()
 {
 }
 
-int TextDialog::exec(const QString &caption, const QString &text, const QString &value="")
+int TextDialog::exec(const QString &caption, const QString &text,
+                     const QString &value)
 {
   setCaption(caption);
   label->setText(text);
   edit->setText(value);
 
   return QDialog::exec();
 }
 
 QString TextDialog::getValue()
 {
   return edit->text();
 }
diff --git a/noncore/tools/remote/helptab.cpp b/noncore/tools/remote/helptab.cpp
index 3c53ab6..ac51e13 100644
--- a/noncore/tools/remote/helptab.cpp
+++ b/noncore/tools/remote/helptab.cpp
@@ -1,27 +1,27 @@
 /*
 Opie-Remote.  emulates remote controlls on an iPaq (and maybe a Zaurus) in Opie.
 Copyright (C) 2002 Thomas Stephens
 
 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
 License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later
 version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 Public License for more details.
 
 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 #include "helptab.h"
 
-HelpTab::HelpTab(QWidget *parent=0, const char *name=0):QWidget(parent, name)
+HelpTab::HelpTab(QWidget *parent, const char *name):QWidget(parent, name)
 {
         QVBoxLayout *layout = new QVBoxLayout(this);
         QString *string = new QString("<qt><h1>Opie-Remote Usage Instructions</h1><p>First, some definitions.  A Remote is a remote entry in an lircd.conf file, it represents one remote you want to emulate.  A Remote Layout is one entry in your ~/Settings/Remote.conf file.  It represents the buttons that you see on your screen.  Each button on a Remote Layout can be mapped to any button in a Remote.  This way you can have, for example, a vcr remote layout, in which all the play/pause/etc buttons are mapped to the buttons on your vcr's remote.  However, most VCR's don't have volume controls, so the volume buttons can be mapped to the volume buttons on your TV.</p><p>The first things you need the lirc and lirc-modules ipkgs.  If you installed this from an ipkg, they should already be there, thanks to the wonderful world of dependencies.  If not, get them.  The next thing you need is an lircd.conf file.  you can get these at <a href=http://www.lirc.org/>http://www.lirc.org/</a>.  Read the documentation there to figure out how to make your own, if one for your remote doesn't exist, or how to have multiple remotes in one lircd.conf file.  Once you have a good lircd.conf file, put it in /etc, kill the lircd daemon (if its running) and do a modprobe lirc_sir.  Then, run lircd again.</p><p>The next thing you want to do is to create a remote layout.  Go to the config tab, and enter a name for your remote layout in the pulldown menu. Dont use the name Remotes, as that could confuse the app.  Hopefully, that will be fixed soon.  after entering the name you want to use, press New, and then select the name again from the pulldown menu (another oddity that i hope to fix).  Then, press each button that you want to map, and a dialog should appear.  Select the remote and button that you want to use, and click OK.  Once you are done, go to the Remote tab, and select the new remote from the dropdown menu.  It should works fine.  If at any time you want to change a remote layout, go to the Config tab, select the layout from the dropdown menu, and change the buttons you want to change.</p><p>This is program is written and maintaned by Thomas (spiralman) Stephens. <a href=mailto:spiralman@softhome.net>spiralman@softhome.net</a>.  Or, look for me on #opie or #handhelds.org on irc.openprojects.net.</p></qt>");
         QTextView *view = new QTextView((const QString &)*string, 0,  this, "view");
         layout->insertSpacing( -1, 5);
         layout->insertWidget(-1, view);
         layout->insertSpacing(-1, 5);
 }
\ No newline at end of file
diff --git a/noncore/tools/remote/helptab.h b/noncore/tools/remote/helptab.h
index f3f99b3..83f24ef 100644
--- a/noncore/tools/remote/helptab.h
+++ b/noncore/tools/remote/helptab.h
@@ -1,26 +1,31 @@
 /*
 Opie-Remote.  emulates remote controlls on an iPaq (and maybe a Zaurus) in Opie.
 Copyright (C) 2002 Thomas Stephens
 
 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
 License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later
 version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 Public License for more details.
 
 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#ifndef HELP_TAB_H
+#define HELP_TAB_H
+
 #include <qwidget.h>
 #include <qtextview.h>
 #include <qstring.h>
 #include <qlayout.h>
 
 class HelpTab : public QWidget
 {
 public:
         HelpTab(QWidget *parent=0, const char *name=0);
-};
\ No newline at end of file
+};
+
+#endif
diff --git a/noncore/tools/remote/recorddialog.cpp b/noncore/tools/remote/recorddialog.cpp
index f7cd30c..cfab730 100644
--- a/noncore/tools/remote/recorddialog.cpp
+++ b/noncore/tools/remote/recorddialog.cpp
@@ -1,81 +1,82 @@
 /*
 Opie-Remote.  emulates remote controlls on an iPaq (and maybe a Zaurus) in Opie.
 Copyright (C) 2002 Thomas Stephens
 
 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
 License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later
 version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 Public License for more details.
 
 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 #include "recorddialog.h"
 
-RecordDialog::RecordDialog(QWidget *parent=0, const char *name=0):QDialog(parent, name)
+RecordDialog::RecordDialog(QWidget *parent, const char *name)
+    :QDialog(parent, name)
 {
         QVBoxLayout *layout = new QVBoxLayout(this);
         QHBoxLayout *hlayout = new QHBoxLayout(this);
-        
+
         layout->insertSpacing(0,5);
         output = new QTextView("Please enter the name of the new remote, and press Return\n", 0, this, "output");
         layout->insertWidget(-1, output);
         layout->insertSpacing(-1, 5);
         layout->insertLayout(-1, hlayout);
         layout->insertSpacing(-1, 5);
 
         hlayout->insertSpacing(0, 5);
         input = new QLineEdit(this, "input");
         hlayout->insertWidget(-1, input, 1);
         hlayout->insertSpacing(-1, 5);
-        
+
         QPushButton *ret = new QPushButton("Return", this, "return");
         hlayout->insertWidget(-1, ret);
         hlayout->insertSpacing(-1, 5);
         connect(ret, SIGNAL(clicked()), this, SLOT(retPressed()) );
         where = 0;
-        
+
         record = new OProcess;
 }
 
 void RecordDialog::retPressed()
 {
         printf("RecordDialog::retPressed: ret pressed\n");
 
         if(where == 0)
         {
                 connect(record, SIGNAL(receivedStdout(OProcess *, char *, int)), this, SLOT(incoming(OProcess *, char *, int)) );
                 connect(record, SIGNAL(receivedStderr(OProcess *, char *, int)), this, SLOT(incoming(OProcess *, char *, int)) );
                 connect(record, SIGNAL(processExited(OProcess *)), this, SLOT(done(OProcess *)) );
                 printf("RecordDialog::retPressed: starting irrecord\n");
                 QString file = "/tmp/" + input->text();
                 *record<<"irrecord"<<file.latin1();
                 if(!record->start(OProcess::NotifyOnExit, OProcess::AllOutput))
                 {
                         QMessageBox *mb = new QMessageBox("Error!",
                                                                                         "Could not start irrecord.  You must<br>use an lirc ipkg that includes<br>irrecord",
                                                                                         QMessageBox::NoIcon,
                                                                                         QMessageBox::Ok,
                                                                                         QMessageBox::NoButton,
                                                                                         QMessageBox::NoButton);
                         mb->exec();
                         return;
                 }
         //      record->resume();
                 where = 1;
         }
 }
 
 void RecordDialog::incoming(OProcess *proc, char *buffer, int len)
 {
         //output->setText(output->text() + QString(buffer).truncate(len-1));
         printf("RecordDialog::incoming: got text from irrecord\n");
 }
 
 void RecordDialog::done(OProcess *proc)
 {
 }
diff --git a/noncore/tools/remote/recorddialog.h b/noncore/tools/remote/recorddialog.h
index 38b2bb4..e4dcae6 100644
--- a/noncore/tools/remote/recorddialog.h
+++ b/noncore/tools/remote/recorddialog.h
@@ -1,43 +1,49 @@
 /*
 Opie-Remote.  emulates remote controlls on an iPaq (and maybe a Zaurus) in Opie.
 Copyright (C) 2002 Thomas Stephens
 
 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
 License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later
 version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 Public License for more details.
 
 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#ifndef RecordDialog_H
+#define RecordDialog_H
+
 #include <qdialog.h>
 #include <qtextview.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qwidget.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
 
 #include <stdio.h>
 
 #include <opie/oprocess.h>
 
 class RecordDialog : public QDialog
 {
         Q_OBJECT
 public:
         RecordDialog(QWidget *parent=0, const char *name=0);
 public slots:
         void retPressed();
         void incoming(OProcess *proc, char *buffer, int len);
         void done(OProcess *proc);
 private:
         QTextView *output;
         QLineEdit *input;
         OProcess *record;
         int where;
-};
\ No newline at end of file
+};
+
+#endif
+