Each file in this commit exhibits a problem where a variable is made in

some way but never used. This is a tricky problem with Qt since almost all
UI forms are made but not used (like QLabel). But I am pretty confident that
these changes are correct and do not have any aspect of a change to the UI.

In most cases, there are just variables that are made and then copied over
(like in iteration over lists or assignment of pointers based on
conditionals).

4 files changed, 7 insertions, 14 deletions

diff --git a/libqtaux/qsplitter.cpp b/libqtaux/qsplitter.cpp
index 39321f8..959d5e1 100644
--- a/libqtaux/qsplitter.cpp
+++ b/libqtaux/qsplitter.cpp
@@ -538,385 +538,385 @@ void QSplitter::moveBefore( int pos, int id, bool upLeft )
 	moveBefore( pos, id-1, upLeft );
     } else if ( s->isSplitter ) {
 	int dd = s->sizer;
 	if ( upLeft ) {
 	    setG( w, pos-dd+1, dd );
 	    moveBefore( pos-dd, id-1, upLeft );
 	} else {
 	    moveBefore( pos-dd, id-1, upLeft );
 	    setG( w, pos-dd+1, dd );
 	}
     } else {
 	int left = pick( w->pos() );
 	int dd = pos - left + 1;
 	dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
 	int newLeft = pos-dd+1;
 	setG( w, newLeft, dd );
 	if ( left != newLeft )
 	    moveBefore( newLeft-1, id-1, upLeft );
     }
 }
 
 
 /*!
   Places the left/top edge of the widget at \a id at position \a pos.
 
   \sa idAfter()
 */
 
 void QSplitter::moveAfter( int pos, int id, bool upLeft )
 {
     QSplitterLayoutStruct *s = id < int(data->list.count()) ?
 			       data->list.at(id) : 0;
     if ( !s )
 	return;
     QWidget *w = s->wid;
     if ( w->isHidden() ) {
 	moveAfter( pos, id+1, upLeft );
     } else if ( pick( w->pos() ) == pos ) {
 	//No need to do anything if it's already there.
 	return;
     } else if ( s->isSplitter ) {
 	int dd = s->sizer;
 	if ( upLeft ) {
 	    setG( w, pos, dd );
 	    moveAfter( pos+dd, id+1, upLeft );
 	} else {
 	    moveAfter( pos+dd, id+1, upLeft );
 	    setG( w, pos, dd );
 	}
     } else {
 	int right = pick( w->geometry().bottomRight() );
 
        	int dd = right - pos + 1;
 	dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
 	int newRight = pos+dd-1;
 	setG( w, pos, dd );
 	moveAfter( newRight+1, id+1, upLeft );
     }
 }
 
 
 /*!
   Returns the valid range of the splitter with id \a id in \a min and \a max.
 
   \sa idAfter()
 */
 
 void QSplitter::getRange( int id, int *min, int *max )
 {
     int minB = 0;	//before
     int maxB = 0;
     int minA = 0;
     int maxA = 0;	//after
     int n = data->list.count();
     if ( id < 0 || id >= n )
 	return;
     int i;
     for ( i = 0; i < id; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->wid->isHidden() ) {
 	    //ignore
 	} else if ( s->isSplitter ) {
 	    minB += s->sizer;
 	    maxB += s->sizer;
 	} else {
 	    minB += pick( minSize(s->wid) );
 	    maxB += pick( s->wid->maximumSize() );
 	}
     }
     for ( i = id; i < n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->wid->isHidden() ) {
 	    //ignore
 	} else 	if ( s->isSplitter ) {
 	    minA += s->sizer;
 	    maxA += s->sizer;
 	} else {
 	    minA += pick( minSize(s->wid) );
 	    maxA += pick( s->wid->maximumSize() );
 	}
     }
     QRect r = contentsRect();
     if ( min )
 	*min = pick(r.topLeft()) + QMAX( minB, pick(r.size())-maxA );
     if ( max )
 	*max = pick(r.topLeft()) + QMIN( maxB, pick(r.size())-minA );
 
 }
 
 
 /*!
   Returns the legal position closest to \a p of the splitter with id \a id.
 
   \sa idAfter()
 */
 
 int QSplitter::adjustPos( int p, int id )
 {
     int min = 0;
     int max = 0;
     getRange( id, &min, &max );
     p = QMAX( min, QMIN( p, max ) );
 
     return p;
 }
 
 
 void QSplitter::doResize()
 {
     QRect r = contentsRect();
     int i;
     int n = data->list.count();
     QArray<QLayoutStruct> a( n );
     for ( i = 0; i< n; i++ ) {
 	a[i].init();
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->wid->isHidden() ) {
 	    a[i].stretch = 0;
 	    a[i].sizeHint = a[i].minimumSize = 0;
 	    a[i].maximumSize = 0;
 	} else if ( s->isSplitter ) {
 	    a[i].stretch = 0;
 	    a[i].sizeHint = a[i].minimumSize = a[i].maximumSize = s->sizer;
 	    a[i].empty = FALSE;
 	} else if ( s->mode == KeepSize ) {
 	    a[i].stretch = 0;
 	    a[i].minimumSize = pick( minSize(s->wid) );
 	    a[i].sizeHint = s->sizer;
 	    a[i].maximumSize = pick( s->wid->maximumSize() );
 	    a[i].empty = FALSE;
 	} else if ( s->mode == FollowSizeHint ) {
 	    a[i].stretch = 0;
 	    a[i].minimumSize = a[i].sizeHint = pick( s->wid->sizeHint() );
 	    a[i].maximumSize = pick( s->wid->maximumSize() );
 	    a[i].empty = FALSE;
 	} else { //proportional
 	    a[i].stretch = s->sizer;
 	    a[i].maximumSize = pick( s->wid->maximumSize() );
 	    a[i].sizeHint = a[i].minimumSize = pick( minSize(s->wid) );
 	    a[i].empty = FALSE;
 	}
     }
 
     qGeomCalc( a, 0, n, pick( r.topLeft() ), pick( r.size() ), 0 );
     for ( i = 0; i< n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( orient == Horizontal )
 	    s->wid->setGeometry( a[i].pos, r.top(), a[i].size, r.height() );
 	else
 	    s->wid->setGeometry( r.left(), a[i].pos, r.width(), a[i].size );
     }
 
 }
 
 
 void QSplitter::recalc( bool update )
 {
     int fi = 2*frameWidth();
     int maxl = fi;
     int minl = fi;
     int maxt = QWIDGETSIZE_MAX;
     int mint = fi;
     int n = data->list.count();
     bool first = TRUE;
     /*
       The splitter before a hidden widget is always hidden.
       The splitter before the first visible widget is hidden.
       The splitter before any other visible widget is visible.
     */
     for ( int i = 0; i< n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( !s->isSplitter ) {
-	    QSplitterLayoutStruct *p = (i > 0) ? p = data->list.at( i-1 ) : 0;
+	    QSplitterLayoutStruct *p = (i > 0) ? data->list.at( i-1 ) : 0;
 	    if ( p && p->isSplitter )
 		if ( first || s->wid->isHidden() )
 		    p->wid->hide(); //may trigger new recalc
 		else
 		    p->wid->show(); //may trigger new recalc
 	    if ( !s->wid->isHidden() )
 		first = FALSE;
 	}
     }
 
     bool empty=TRUE;
     for ( int j = 0; j< n; j++ ) {
 	QSplitterLayoutStruct *s = data->list.at(j);
 	if ( !s->wid->isHidden() ) {
 	    empty = FALSE;
 	    if ( s->isSplitter ) {
 		minl += s->sizer;
 		maxl += s->sizer;
 	    } else {
 		QSize minS = minSize(s->wid);
 		minl += pick( minS );
 		maxl += pick( s->wid->maximumSize() );
 		mint = QMAX( mint, trans( minS ));
 		int tm = trans( s->wid->maximumSize() );
 		if ( tm > 0 )
 		    maxt = QMIN( maxt, tm );
 	    }
 	}
     }
     if ( empty )
 	maxl = maxt = 0;
     else
 	maxl = QMIN( maxl, QWIDGETSIZE_MAX );
     if ( maxt < mint )
 	maxt = mint;
 
     if ( orient == Horizontal ) {
 	setMaximumSize( maxl, maxt );
 	setMinimumSize( minl, mint );
     } else {
 	setMaximumSize( maxt, maxl );
 	setMinimumSize( mint, minl );
     }
     if ( update )
 	doResize();
 }
 
 /*! \enum QSplitter::ResizeMode
 
   This enum type describes how QSplitter will resize each of its child widgets.  The currently defined values are: <ul>
 
   <li> \c Stretch - the widget will be resized when the splitter
   itself is resized.
 
   <li> \c KeepSize - QSplitter will try to keep this widget's size
   unchanged.
 
   <li> \c FollowSizeHint - QSplitter will resize the widget when its
   size hint changes.
 
   </ul>
 
 */
 
 /*!
   Sets resize mode of \a w to \a mode.
 
   \sa ResizeMode
 */
 
 void QSplitter::setResizeMode( QWidget *w, ResizeMode mode )
 {
     processChildEvents();
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( s->wid == w  ) {
 	    s->mode = mode;
 	    return;
 	}
 	s = data->list.next();
     }
     s = addWidget( w, TRUE );
     s->mode = mode;
 }
 
 
 /*!
   Returns TRUE if opaque resize is on, FALSE otherwise.
 
   \sa setOpaqueResize()
 */
 
 bool QSplitter::opaqueResize() const
 {
     return data->opaque;
 }
 
 
 /*!
   Sets opaque resize to \a on. Opaque resize is initially turned off.
 
   \sa opaqueResize()
 */
 
 void QSplitter::setOpaqueResize( bool on )
 {
     data->opaque = on;
 }
 
 
 /*!
   Moves \a w to the leftmost/top position.
 */
 
 void QSplitter::moveToFirst( QWidget *w )
 {
     processChildEvents();
     bool found = FALSE;
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( s->wid == w  ) {
 	    found = TRUE;
 	    QSplitterLayoutStruct *p = data->list.prev();
 	    if ( p ) { // not already at first place
 		data->list.take(); //take p
 		data->list.take(); // take s
 		data->list.insert( 0, p );
 		data->list.insert( 0, s );
 	    }
 	    break;
 	}
 	s = data->list.next();
     }
      if ( !found )
 	addWidget( w, TRUE );
      recalcId();
 }
 
 
 /*!
   Moves \a w to the rightmost/bottom position.
 */
 
 void QSplitter::moveToLast( QWidget *w )
 {
     processChildEvents();
     bool found = FALSE;
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( s->wid == w  ) {
 	    found = TRUE;
 	    data->list.take(); // take s
 	    QSplitterLayoutStruct *p = data->list.current();
 	    if ( p ) { // the splitter handle after s
 		data->list.take(); //take p
 		data->list.append( p );
 	    }
 	    data->list.append( s );
 	    break;
 	}
 	s = data->list.next();
     }
      if ( !found )
 	addWidget( w);
      recalcId();
 }
 
 
 void QSplitter::recalcId()
 {
     int n = data->list.count();
     for ( int i = 0; i < n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->isSplitter )
 	    ((QSplitterHandle*)s->wid)->setId(i);
     }
 }
 
 
 /*!\reimp
 */
 QSize QSplitter::sizeHint() const
 {
     constPolish();
     int l = 0;
     int t = 0;
     if ( children() ) {
 	const QObjectList * c = children();
 	QObjectListIt it( *c );
 	QObject * o;
 
 	while( (o=it.current()) != 0 ) {
diff --git a/noncore/apps/tinykate/libkate/document/katesyntaxdocument.cpp b/noncore/apps/tinykate/libkate/document/katesyntaxdocument.cpp
index 9fa4452..d8f5aa7 100644
--- a/noncore/apps/tinykate/libkate/document/katesyntaxdocument.cpp
+++ b/noncore/apps/tinykate/libkate/document/katesyntaxdocument.cpp
@@ -1,254 +1,252 @@
 /***************************************************************************
                           katesyntaxdocument.cpp  -  description
                              -------------------
     begin                : Sat 31 March 2001
     copyright            : (C) 2001,2002 by Joseph Wenninger
     email                : jowenn@kde.org
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "katesyntaxdocument.h"
 #include "kateconfig.h"
 #include "kdebug.h"
 #include "kstddirs.h"
 #include "klocale.h"
 #include "kmessagebox.h"
 #include "kglobal.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qfile.h>
 #include <qstringlist.h>
 #include <qdir.h>
 
 SyntaxDocument::SyntaxDocument()
 {
   m_root=0;
   currentFile="";
   setupModeList();
 }
 
 void SyntaxDocument::setIdentifier(const QString& identifier)
 {
 #warning FIXME  delete m_root;
   m_root=Opie::Core::XMLElement::load(identifier);
   if (!m_root)    KMessageBox::error( 0L, i18n("Can't open %1").arg(identifier) );
 
 }
 
 SyntaxDocument::~SyntaxDocument()
 {
 }
 
 void SyntaxDocument::setupModeList(bool force)
 {
 
   if (myModeList.count() > 0) return;
 
   KateConfig *config=KGlobal::config();
-  KStandardDirs *dirs = KGlobal::dirs();
 
-//  QStringList list=dirs->findAllResources("data","kate/syntax/*.xml",false,true);
   QString path=QPEApplication::qpeDir() +"share/tinykate/syntax/";
 
   QDir dir(path);
   QStringList list=dir.entryList("*.xml");
 
   for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it )
   {
     QString Group="Highlighting_Cache"+path+*it;
     if ((config->hasGroup(Group)) && (!force))
     {
       config->setGroup(Group);
       syntaxModeListItem *mli=new syntaxModeListItem;
       mli->name = config->readEntry("name","");
       mli->section = config->readEntry("section","");
       mli->mimetype = config->readEntry("mimetype","");
       mli->extension = config->readEntry("extension","");
       mli->identifier = path+*it;
       myModeList.append(mli);
     }
     else
     {
     odebug << "Found a description file:"+path+(*it) << oendl;
         setIdentifier(path+(*it));
         Opie::Core::XMLElement *e=m_root;
         if (e)
         {
       e=e->firstChild();
       odebug << e->tagName() << oendl;
           if (e->tagName()=="language")
           {
             syntaxModeListItem *mli=new syntaxModeListItem;
             mli->name = e->attribute("name");
             mli->section = e->attribute("section");
             mli->mimetype = e->attribute("mimetype");
             mli->extension = e->attribute("extensions");
         odebug << QString("valid description for: %1/%2").arg(mli->section).arg(mli->name) << oendl;
             if (mli->section.isEmpty())
               mli->section=i18n("Other");
 
             mli->identifier = path+(*it);
             config->setGroup(Group);
             config->writeEntry("name",mli->name);
             config->writeEntry("section",mli->section);
             config->writeEntry("mimetype",mli->mimetype);
             config->writeEntry("extension",mli->extension);
             myModeList.append(mli);
           }
         }
     }
   }
   config->write();
 //  config->sync();
 }
 
 SyntaxModeList SyntaxDocument::modeList()
 {
   return myModeList;
 }
 
 bool SyntaxDocument::nextGroup( syntaxContextData* data)
 {
   if(!data) return false;
 
   if (!data->currentGroup)
     data->currentGroup=data->parent->firstChild();
   else
     data->currentGroup=data->currentGroup->nextChild();
 
   data->item=0;
 
   if (!data->currentGroup)
     return false;
   else
     return true;
 }
 
 bool SyntaxDocument::nextItem( syntaxContextData* data)
 {
   if(!data) return false;
 
   if (!data->item)
     data->item=data->currentGroup->firstChild();
   else
     data->item=data->item->nextChild();
 
   if (!data->item)
     return false;
   else
     return true;
 }
 
 QString SyntaxDocument::groupItemData( syntaxContextData* data,QString name)
 {
   if(!data)
     return QString::null;
 
   if ( (data->item) && (name.isEmpty()))
     return data->item->tagName();
 
   if (data->item)
     return data->item->attribute(name);
   else
     return QString();
 }
 
 QString SyntaxDocument::groupData( syntaxContextData* data,QString name)
 {
   if(!data)
     return QString::null;
 
   if (data->currentGroup)
     return data->currentGroup->attribute(name);
   else
     return QString();
 }
 
 void SyntaxDocument::freeGroupInfo( syntaxContextData* data)
 {
   if (data)
     delete data;
 }
 
 syntaxContextData* SyntaxDocument::getSubItems(syntaxContextData* data)
 {
   syntaxContextData *retval=new syntaxContextData;
     retval->parent=0;
     retval->currentGroup=0;
     retval->item=0;
   if (data != 0)
   {
     retval->parent=data->currentGroup;
     retval->currentGroup=data->item;
     retval->item=0;
    }
 
   return retval;
 }
 
 syntaxContextData* SyntaxDocument::getConfig(const QString& mainGroupName, const QString &Config)
 {
   Opie::Core::XMLElement *e = m_root->firstChild()->firstChild();
 
   while (e)
   {
     kdDebug(13010)<<"in SyntaxDocument::getGroupInfo (outer loop) " <<endl;
 
     if (e->tagName().compare(mainGroupName)==0 )
     {
        Opie::Core::XMLElement *e1=e->firstChild();
 
       while (e1)
       {
         kdDebug(13010)<<"in SyntaxDocument::getGroupInfo (inner loop) " <<endl;
 
         if (e1->tagName()==Config)
         {
           syntaxContextData *data=new ( syntaxContextData);
       data->currentGroup=0;
       data->parent=0;
           data->item=e1;
           return data;
         }
 
         e1=e1->nextChild();
       }
 
       kdDebug(13010) << "WARNING :returning null 3"<< endl;
       return 0;
     }
 
     e=e->nextChild();
   }
 
   kdDebug(13010) << "WARNING :returning null 4"  << endl;
   return 0;
 }
 
 
 
 syntaxContextData* SyntaxDocument::getGroupInfo(const QString& mainGroupName, const QString &group)
 {
 
   Opie::Core::XMLElement *e=m_root->firstChild()->firstChild();
 
   while (e)
   {
     kdDebug(13010)<<"in SyntaxDocument::getGroupInfo (outer loop) " <<endl;
 
     if (e->tagName().compare(mainGroupName)==0 )
     {
       Opie::Core::XMLElement *e1=e->firstChild();
 
diff --git a/noncore/apps/tinykate/mainwindow/tinykate.cpp b/noncore/apps/tinykate/mainwindow/tinykate.cpp
index e87464e..e920d5b 100644
--- a/noncore/apps/tinykate/mainwindow/tinykate.cpp
+++ b/noncore/apps/tinykate/mainwindow/tinykate.cpp
@@ -14,414 +14,412 @@
  *   ONLY VERSION 2 OF THE LICENSE IS APPLICABLE                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "tinykate.h"
 
 #include "katedocument.h"
 #include "kglobal.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <opie2/ofiledialog.h>
 #include <opie2/oresource.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qaction.h>
 #include <qtoolbutton.h>
 #include <qmenubar.h>
 #include <qmessagebox.h>
 
 
 using namespace Opie::Ui;
 TinyKate::TinyKate( QWidget *parent, const char *name, WFlags f) :
         QMainWindow( parent, name, f )
 {
     shutDown=false;
     nextUnnamed=0;
     currentView=0;
     viewCount=0;
     setCaption(tr("TinyKATE"));
     KGlobal::setAppName("TinyKATE");
 
     QMenuBar *mb = new QMenuBar( this );
     mb->setMargin( 0 );
 
     tabwidget=new OTabWidget(this);
     setCentralWidget(tabwidget);
     connect(tabwidget,SIGNAL(currentChanged(QWidget*)),this,SLOT(slotCurrentChanged(QWidget*)));
 
     //FILE ACTIONS
     QPopupMenu *popup = new QPopupMenu( this );
 
     // Action for creating a new document
     QAction *a = new QAction( tr( "New" ), Opie::Core::OResource::loadPixmap( "new", Opie::Core::OResource::SmallIcon ),
                               QString::null, 0, this, 0 );
     a->addTo( popup );
     connect(a, SIGNAL(activated()), this, SLOT(slotNew()));
 
     // Action for opening an exisiting document
     a = new QAction( tr( "Open" ), Opie::Core::OResource::loadPixmap( "fileopen", Opie::Core::OResource::SmallIcon ),
                      QString::null, 0, this, 0 );
     a->addTo(popup);
     connect(a, SIGNAL(activated()), this, SLOT(slotOpen()));
 
 
     // Action for saving  document
     a = new QAction( tr( "Save" ), Opie::Core::OResource::loadPixmap( "save", Opie::Core::OResource::SmallIcon ),
                      QString::null, 0, this, 0 );
     a->addTo(popup);
     connect(a, SIGNAL(activated()), this, SLOT(slotSave()));
 
     // Action for saving document to a new name
     a = new QAction( tr( "Save As" ), Opie::Core::OResource::loadPixmap( "save", Opie::Core::OResource::SmallIcon ),
                      QString::null, 0, this, 0 );
     a->addTo(popup);
     connect(a, SIGNAL(activated()), this, SLOT(slotSaveAs()));
 
     // Action for closing the currently active document
     a = new QAction( tr( "Close" ), Opie::Core::OResource::loadPixmap( "quit_icon", Opie::Core::OResource::SmallIcon ),
                      QString::null, 0, this, 0 );
     a->addTo(popup);
     connect(a, SIGNAL(activated()), this, SLOT(slotClose()));
 
 
     mb->insertItem(tr("File"),popup);
 
     //EDIT ACTIONS
     popup = new QPopupMenu( this );
     bool useBigIcon = qApp->desktop()->size().width() > 330;
 
     // Action for cutting text
     editCut = new QToolButton( 0 );
     editCut->setUsesBigPixmap( useBigIcon );
     editCut->setAutoRaise( true );
     editCut->setIconSet( Opie::Core::OResource::loadPixmap( "cut", Opie::Core::OResource::SmallIcon ) );
 
     // Action for Copying text
     editCopy = new QToolButton( 0 );
     editCopy->setUsesBigPixmap( useBigIcon );
     editCopy->setAutoRaise( true );
     editCopy->setIconSet( Opie::Core::OResource::loadPixmap( "copy", Opie::Core::OResource::SmallIcon ) );
 
     // Action for pasting text
     editPaste =  new QToolButton( 0 );
     editPaste->setUsesBigPixmap( useBigIcon );
     editPaste->setAutoRaise( true );
     editPaste->setIconSet( Opie::Core::OResource::loadPixmap( "paste", Opie::Core::OResource::SmallIcon ) );
 
     // Action for finding text
     editFind = new QAction( tr( "Find..." ), Opie::Core::OResource::loadPixmap( "find", Opie::Core::OResource::SmallIcon ),
                      QString::null, 0, this, 0 );
     editFind->addTo(popup);
 
     // Action for replacing text
     editReplace = new QAction( tr( "Replace..." ), QString::null, 0, this, 0 );
     editReplace->addTo(popup);
 
     // Action for going to a specific line
     editGotoLine = new QAction( tr( "Goto Line..." ), QString::null, 0, this, 0 );
     editGotoLine->addTo(popup);
 
     // Action for undo
     editUndo = new QToolButton( 0 );
     editUndo->setUsesBigPixmap( useBigIcon );
     editUndo->setAutoRaise( true );
     editUndo->setIconSet( Opie::Core::OResource::loadPixmap( "undo", Opie::Core::OResource::SmallIcon ) );
 
     // Action for redo
     editRedo = new QToolButton( 0 );
     editRedo->setUsesBigPixmap( useBigIcon );
     editRedo->setAutoRaise( true );
     editRedo->setIconSet( Opie::Core::OResource::loadPixmap( "redo", Opie::Core::OResource::SmallIcon ) );
 
     mb->insertItem(tr("Edit"),popup);
 
     //VIEW ACITONS
     popup = new QPopupMenu( this );
 
     viewIncFontSizes = new QAction( tr( "Font +" ), QString::null, 0, this, 0 );
     viewIncFontSizes->addTo( popup );
 
     viewDecFontSizes = new QAction( tr( "Font -" ), QString::null, 0, this, 0 );
     viewDecFontSizes->addTo( popup );
 
     mb->insertItem(tr("View"),popup);
 
     popup = new QPopupMenu( this );
     mb->insertItem(tr("Utils"),popup);
 
 
     mb->insertItem( editCut );
     mb->insertItem( editCopy );
     mb->insertItem( editPaste );
     mb->insertItem( editUndo );
     mb->insertItem(  editRedo );
 
 
     //Highlight management
     hlmenu=new QPopupMenu(this);
     HlManager *hlm=HlManager::self();
     for (int i=0;i<hlm->highlights();i++)
     {
         hlmenu->insertItem(hlm->hlName(i),i);
     }
     popup->insertItem(tr("Highlighting"),hlmenu);
 
 
     utilSettings = new QAction( tr( "Settings" ),
                                 Opie::Core::OResource::loadPixmap( "SettingsIcon", Opie::Core::OResource::SmallIcon ),
                                 QString::null, 0, this, 0 );
     utilSettings->addTo( popup);
 
     if( qApp->argc() > 1) open(qApp->argv()[1]);
     else slotNew();
 
 }
 
 TinyKate::~TinyKate( )
 {
     owarn << "TinyKate destructor\n" << oendl;
 
     if( KGlobal::config() != 0 )
     {
         owarn << "deleting KateConfig object..\n" << oendl;
         delete KGlobal::config();
     }
 }
 
 void TinyKate::slotOpen( )
 {
     QString filename = OFileDialog::getOpenFileName( OFileSelector::EXTENDED_ALL,
                        QString::null);
     if (!filename.isEmpty())
     {
         open(filename);
     }
 }
 
 void TinyKate::open(const QString & filename)
 {
     KateDocument *kd= new KateDocument(false, false, this,0,this);
-    KTextEditor::View *kv;
     QString realFileName;
     //check if filename is a .desktop file
     if ( filename.find( ".desktop", 0, true ) != -1 ) {
         switch ( QMessageBox::warning( this, tr( "TinyKATE" ),
                                        tr("TinyKATE has detected<BR>you selected a <B>.desktop</B> file.<BR>Open <B>.desktop</B> file or <B>linked</B> file?" ),
                                        tr(".desktop File"),
                                        tr("Linked Document"), 0, 1, 1 ) )
         {
         case 0: //desktop
             realFileName = filename;
             break;
         case 1: //linked
             DocLnk docLnk( filename );
             realFileName = docLnk.file();
             break;
         };
     } else {
 	    realFileName = filename;
     }
 
     QFileInfo fileInfo( realFileName );
     QString filenamed = fileInfo.fileName();
-    tabwidget->addTab(kv=kd->createView(tabwidget,"bLAH"),"tinykate/tinykate", filenamed );
+    tabwidget->addTab(kd->createView(tabwidget,"Unnamed kateview"),"tinykate/tinykate", filenamed );
     odebug << realFileName << oendl;
 
     kd->setDocName( filenamed);
     kd->open( realFileName );
     viewCount++;
 }
 
 void TinyKate::setDocument(const QString& fileref)
 {
     open( fileref );
 }
 
 void TinyKate::slotCurrentChanged( QWidget * view)
 {
     if (currentView)
     {
 
         disconnect(editCopy,SIGNAL(clicked()),currentView,SLOT(copy()));
         disconnect(editCut,SIGNAL(clicked()),currentView,SLOT(cut()));
         disconnect(editPaste,SIGNAL(clicked()),currentView,SLOT(paste()));
         disconnect(editUndo,SIGNAL(clicked()),currentView,SLOT(undo()));
         disconnect(editRedo,SIGNAL(clicked()),currentView,SLOT(redo()));
         disconnect(editFind,SIGNAL(activated()),currentView,SLOT(find()));
         disconnect(editReplace,SIGNAL(activated()),currentView,SLOT(replace()));
         disconnect(editGotoLine,SIGNAL(activated()),currentView,SLOT(gotoLine()));
         disconnect(viewIncFontSizes,SIGNAL(activated()), currentView,SLOT(slotIncFontSizes()));
         disconnect(viewDecFontSizes,SIGNAL(activated()), currentView,SLOT(slotDecFontSizes()));
         disconnect(hlmenu,SIGNAL(activated(int)), currentView,SLOT(setHl(int)));
         disconnect(utilSettings,SIGNAL(activated()), currentView,SLOT(configDialog()));
     }
 
     currentView=(KTextEditor::View*)view;
 
     connect(editCopy,SIGNAL(clicked()),currentView,SLOT(copy()));
     connect(editCut,SIGNAL(clicked()),currentView,SLOT(cut()));
     connect(editPaste,SIGNAL(clicked()),currentView,SLOT(paste()));
     connect(editUndo,SIGNAL(clicked()),currentView,SLOT(undo()));
     connect(editRedo,SIGNAL(clicked()),currentView,SLOT(redo()));
     connect(editFind,SIGNAL(activated()),currentView,SLOT(find()));
     connect(editReplace,SIGNAL(activated()),currentView,SLOT(replace()));
     connect(editGotoLine,SIGNAL(activated()),currentView,SLOT(gotoLine()));
     connect(viewIncFontSizes,SIGNAL(activated()), currentView,SLOT(slotIncFontSizes()));
     connect(viewDecFontSizes,SIGNAL(activated()), currentView,SLOT(slotDecFontSizes()));
     connect(hlmenu,SIGNAL(activated(int)), currentView,SLOT(setHl(int)));
     connect(utilSettings,SIGNAL(activated()), currentView,SLOT(configDialog()));
 
 }
 
 void TinyKate::slotNew( )
 {
     KateDocument *kd= new KateDocument(false, false, this,0,this);
-    KTextEditor::View *kv;
     
     kd->setDocName(tr("Unnamed %1").arg(nextUnnamed++));
     kd->setNewDoc(true);
-    tabwidget->addTab(kv=kd->createView(tabwidget,"BLAH"),
+    tabwidget->addTab(kd->createView(tabwidget,"Unnamed"),
                       "tinykate/tinykate",
                       kd->docName());
     viewCount++;
 }
 
 bool TinyKate::checkSave() {
     if (currentView==0) return true;
 
     KateView *kv = (KateView*) currentView;
     if(kv->isModified()) {
         KateDocument *kd = (KateDocument*) kv->document();
         switch( QMessageBox::information( 0, (tr("TinyKATE")),
                                         (tr("Do you want to save\n"
                                             "changes to the document\n"
                                             "%1?\n").arg(kd->docName())),
                                         (tr("Save")), (tr("Don't Save")), (tr("&Cancel")), 2, 2 ) )
         {
             case 0:
             {
                 return saveDocument();
             }
             break;
     
             case 1:
             {
                 return true;
             }
             break;
     
             default:
             {
                 return false;
             }
             break;
         };
     }
     else {
         return true;
     }
 }
 
 bool TinyKate::closeDocument()
 {
     if (currentView==0) return true;
     KTextEditor::View *dv=currentView;
     if(checkSave()) {
         currentView=0;
         tabwidget->removePage(dv);
         delete dv->document();
         viewCount--;
         if ((!viewCount) && (!shutDown))  slotNew();
         return true;
     }
     else
         return false;
 }
 
 void TinyKate::slotClose( )
 {
     closeDocument();
 }
 
 bool TinyKate::saveDocument()
 {
     // feel free to make this how you want
     if (currentView==0) return false;
 
     //  KateView *kv = (KateView*) currentView;
     KateDocument *kd = (KateDocument*) currentView->document();
     //  odebug << "saving file "+kd->docName() << oendl;
     if( kd->isNewDoc()) {
         return saveDocumentAs();
     }
     else
         return kd->saveFile();
     // FIXME check result of saveFile and show message if failed?
     //    kv->save();
     //    kd->saveFile();
 }
 
 bool TinyKate::saveDocumentAs()
 {
     if (currentView==0) return false;
 
     bool result = false;
     KateDocument *kd = (KateDocument*) currentView->document();
 
     QString filename= OFileDialog::getSaveFileName(OFileSelector::EXTENDED_ALL,
                       QString::null);
     if (!filename.isEmpty())
     {
         odebug << "saving file "+filename << oendl;
         QFileInfo fi(filename);
         if(fi.exists()) {
             if ( QMessageBox::warning(this,tr("TinyKATE"),
                                   tr("The file %1\n"
                                      "already exists.\n\n"
                                      "Are you sure you want to\n"
                                      "overwrite it?")
                                      .arg(fi.fileName()),
                                   tr("Yes"),tr("No"),0,0,1) != 0) {
                 return false;
             }
         }
         QString filenamed = fi.fileName();
         kd->setDocFile( filename);
         kd->setDocName( filenamed);
         kd->setNewDoc(false);
         result = kd->saveFile();
         // FIXME check result of saveFile and show message if failed?
         tabwidget->changeTab( tabwidget->currentWidget(), "tinykate/tinykate", filenamed );
     }
     return result;
 }
 
 void TinyKate::slotSave()
 {
     saveDocument();
 }
 
 void TinyKate::slotSaveAs()
 {
     saveDocumentAs();
 }
 
 void TinyKate::closeEvent(QCloseEvent *e) {
     // Close all documents
     shutDown = true;
     while (currentView!=0)
     {
         if(!closeDocument()) {
             // User cancelled
             shutDown=false;
             break;
         }
     }
 
     if(shutDown)
         e->accept();
     else
         e->ignore();
 }
diff --git a/noncore/graphics/opie-eye/impl/dcim/dcim_lister.cpp b/noncore/graphics/opie-eye/impl/dcim/dcim_lister.cpp
index 147eb9c..d4f9943 100644
--- a/noncore/graphics/opie-eye/impl/dcim/dcim_lister.cpp
+++ b/noncore/graphics/opie-eye/impl/dcim/dcim_lister.cpp
@@ -1,181 +1,178 @@
 /*
  * GPLv2 zecke@handhelds.org
  */
 
 #include "dcim_lister.h"
 #include <lib/slavemaster.h>
 
 #include <opie2/odebug.h>
 #include <qpe/storage.h>
 
 #include <qdir.h>
 #include <qfileinfo.h>
 #include <qimage.h>
 
 DCIM_DirLister::DCIM_DirLister()
     : PDirLister( "dcim_dirlister" )
 {
 
     /*
      * create a SlaveMaster and lets connect the signal of
      * it to our interface
      */
     SlaveHelper::slaveConnectSignals( this );
     m_mode = ListingUnknown;
 }
 
 DCIM_DirLister::~DCIM_DirLister() {}
 
 QString DCIM_DirLister::defaultPath()const {
     m_mode = ListingStart;
     return QString::null;
 }
 
 QString DCIM_DirLister::setStartPath( const QString& str) {
     /**
      * IconView adds a '/' to path. Lets strip
      * that.
      */
     QString st = str.mid( 1 );
     if ( ListingStart == m_mode && m_map.contains( st ) ) {
         m_path = m_map[st]+ "/dcim";
         m_mode = ListingFolder;
     }else if ( m_mode == ListingFolder ) {
         m_mode = ListingFiles;
         m_path = str;
     }else if ( m_mode == ListingReFolder ) {
         m_mode = ListingFolder;
     }
 
     owarn << " StartPath2 " << str << " " << m_path << oendl;
 
     return m_path;
 }
 
 
 QString DCIM_DirLister::currentPath()const {
     return m_path;
 }
 
 /*
  * depending on the mode we will either
  * Find Digital Cameras
  */
 QStringList DCIM_DirLister::folders()const {
     QStringList lst;
 
     switch( m_mode ) {
     case ListingUnknown:
     case ListingStart:
         lst = findCameras();
         break;
     case ListingFolder:
         lst = findAlbums();
         break;
     case ListingFiles:
     default:
         break;
     }
 
     return lst;
 }
 
 QStringList DCIM_DirLister::files()const {
     if ( m_mode != ListingFiles )
         return QStringList();
     else
         return findImages();
 }
 
 QString DCIM_DirLister::dirUp( const QString& p )const {
     QString str;
 
     switch( m_mode ) {
     case ListingFiles:
         m_mode = ListingReFolder;
         str = PDirLister::dirUp( p );
         break;
     case ListingFolder:
         m_mode = ListingStart;
         break;
     case ListingUnknown:
     case ListingStart:
     default:
         break;
     }
 
     /* down cases */
     owarn << " New String " << str << " old path " << m_mode << oendl;
     m_path = str;
     return str;
 }
 
 
 QStringList DCIM_DirLister::findCameras()const {
     QStringList lst;
     StorageInfo inf;
 
     m_map.clear();
 
     const QList<FileSystem> &list = inf.fileSystems();
-    QListIterator<FileSystem> it( list );
 
-
-    FileSystem *sys;
-    for ( sys = it.current(); (sys=it.current())!=0  ; ++it )
-        if ( QFileInfo( sys->path() + "/dcim/" ).exists() ) {
-            lst << sys->name();
-            m_map.insert( sys->name(), sys->path() );
+    for ( QListIterator<FileSystem> it( list ); it.current()!=0  ; ++it )
+        if ( QFileInfo( it.current()->path() + "/dcim/" ).exists() ) {
+            lst << it.current()->name();
+            m_map.insert( it.current()->name(), it.current()->path() );
         }
 
     if ( lst.isEmpty() ) {
         m_mode = ListingUnknown;
         lst << QObject::tr("Error no Camera Dir found");
     }else
         m_mode = ListingStart;
 
     return lst;
 }
 
 QStringList DCIM_DirLister::findAlbums()const {
     QStringList lst = QDir( m_path ).entryList( QDir::Dirs );
     lst.remove( "."  );
     lst.remove( ".." );
 
     return lst;
 }
 
 QStringList DCIM_DirLister::findImages()const {
     return QDir( m_path ).entryList("*.jpg *.jpeg *.png", QDir::Files );
 }
 
 void DCIM_DirLister::deleteImage( const QString& fl ) {
     QFileInfo inf( fl );
     QFile::remove( fl );
     QFile::remove( inf.dirPath ()+"/preview/"+
                    inf.fileName() );
 }
 
 void DCIM_DirLister::thumbNail( const QString& _str, int w, int h ) {
     QFileInfo inf( _str );
     QString str = QFileInfo( inf.dirPath()+"/preview"+ inf.fileName() ).exists() ?
                   inf.dirPath()+"/preview"+ inf.fileName() : _str;
 
     SlaveMaster::self()->thumbNail( str, w, h );
 }
 
 QImage DCIM_DirLister::image( const QString& str,  Factor f,  int m ) {
     return SlaveMaster::self()->image( str, f, m );
 }
 
 void DCIM_DirLister::imageInfo( const QString& str ) {
     SlaveMaster::self()->thumbInfo( str );
 }
 
 void DCIM_DirLister::fullImageInfo( const QString& str ) {
     SlaveMaster::self()->imageInfo( str );
 }
 
 QString DCIM_DirLister::nameToFname( const QString& name )const {
     return name;
 }