16 files changed, 23 insertions, 23 deletions
diff --git a/core/apps/calibrate/main.cpp b/core/apps/calibrate/main.cpp
index cb041c9..d1ad083 100644
--- a/core/apps/calibrate/main.cpp
+++ b/core/apps/calibrate/main.cpp
@@ -1,42 +1,42 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "calibrate.h"
 #include <qfile.h>
 #include <qpe/qpeapplication.h>
 int main( int argc, char ** argv )
 {
    QPEApplication a( argc, argv );
    int retval = 0;
-#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
    if ( !QFile::exists( "/etc/pointercal" ) ) {
        // Make sure calibration widget starts on top.
        Calibrate *cal = new Calibrate;
        a.setMainWidget(cal);
        a.showMainWidget(cal);
        retval = a.exec();
        delete cal;
    }
 #endif
    return retval;
 }
diff --git a/core/apps/embeddedkonsole/TEWidget.cpp b/core/apps/embeddedkonsole/TEWidget.cpp
index 8214e7d..d0850e3 100644
--- a/core/apps/embeddedkonsole/TEWidget.cpp
+++ b/core/apps/embeddedkonsole/TEWidget.cpp
@@ -857,502 +857,502 @@ void TEWidget::mouseDoubleClickEvent(QMouseEvent* ev)
  {
    // set the start...
     int x = bgnSel.x();
     while ( x > 0 && charClass(image[i-1].c) == selClass )
     { i--; x--; }
     bgnSel.setX(x);
     emit beginSelectionSignal( bgnSel.x(), bgnSel.y() );
     // set the end...
     i = loc( endSel.x(), endSel.y() );
     x = endSel.x();
     while( x < columns-1 && charClass(image[i+1].c) == selClass )
     { i++; x++ ; }
     endSel.setX(x);
     actSel = 2; // within selection
     emit extendSelectionSignal( endSel.x(), endSel.y() );
     emit endSelectionSignal(preserve_line_breaks);
     preserve_line_breaks = TRUE;
   }
 }
 void TEWidget::focusInEvent( QFocusEvent * )
 {
    // do nothing, to prevent repainting
 }
 void TEWidget::focusOutEvent( QFocusEvent * )
 {
    // do nothing, to prevent repainting
 }
 bool TEWidget::focusNextPrevChild( bool next )
 {
  if (next)
    return false; // This disables changing the active part in konqueror
                  // when pressing Tab
  return QFrame::focusNextPrevChild( next );
 }
 int TEWidget::charClass(char ch) const
 {
    // This might seem like overkill, but imagine if ch was a Unicode
    // character (Qt 2.0 QChar) - it might then be sensible to separate
    // the different language ranges, etc.
    if ( isspace(ch) ) return ' ';
    static const char *word_characters = ":@-./_~";
    if ( isalnum(ch) || strchr(word_characters, ch) )
    return 'a';
    // Everything else is weird
    return 1;
 }
 void TEWidget::setMouseMarks(bool on)
 {
  mouse_marks = on;
  setCursor( mouse_marks ? ibeamCursor : arrowCursor );
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                               Clipboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 #undef KeyPress
 void TEWidget::emitSelection()
 // Paste Clipboard by simulating keypress events
 {
 #ifndef QT_NO_CLIPBOARD
  QString text = QApplication::clipboard()->text();
        //qDebug(text);
  if ( ! text.isNull())
  {
    text.replace(QRegExp("\n"), "\r");
    QKeyEvent e(QEvent::KeyPress, 0, -1, 0, text);
    emit keyPressedSignal(&e); // expose as a big fat keypress event
    emit clearSelectionSignal();
  }
 #endif
 }
 void TEWidget::emitText(QString text)
 {
  QKeyEvent e(QEvent::KeyPress, 0, -1, 0, text);
  emit keyPressedSignal(&e); // expose as a big fat keypress event
 }
 void TEWidget::pasteClipboard( )
 {
  emitSelection();
 }
 void TEWidget::setSelection(const QString& t)
 {
 #ifndef QT_NO_CLIPBOARD
  // Disconnect signal while WE set the clipboard
  QObject *cb = QApplication::clipboard();
  QObject::disconnect( cb, SIGNAL(dataChanged()),
                     this, SLOT(onClearSelection()) );
  QApplication::clipboard()->setText(t);
  QObject::connect( cb, SIGNAL(dataChanged()),
                     this, SLOT(onClearSelection()) );
 #endif
 }
 void TEWidget::onClearSelection()
 {
  emit clearSelectionSignal();
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Keyboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 //FIXME: an `eventFilter' has been installed instead of a `keyPressEvent'
 //       due to a bug in `QT' or the ignorance of the author to prevent
 //       repaint events being emitted to the screen whenever one leaves
 //       or reenters the screen to/from another application.
 //
 //   Troll says one needs to change focusInEvent() and focusOutEvent(),
 //   which would also let you have an in-focus cursor and an out-focus
 //   cursor like xterm does.
 // for the auto-hide cursor feature, I added empty focusInEvent() and
 // focusOutEvent() so that update() isn't called.
 // For auto-hide, we need to get keypress-events, but we only get them when
 // we have focus.
 void TEWidget::doScroll(int lines)
 {
  scrollbar->setValue(scrollbar->value()+lines);
 }
 void TEWidget::doHScroll(int lines) {
  hScrollbar->setValue( hScrollbar->value()+lines);
 }
 bool TEWidget::eventFilter( QObject *obj, QEvent *e )
 {
    if ( (e->type() == QEvent::Accel ||
          e->type() == QEvent::AccelAvailable ) && qApp->focusWidget() == this )  {
        static_cast<QKeyEvent *>( e )->ignore();
        return true;
    }
    if ( obj != this /* when embedded */ && obj != parent() /* when standalone */ )
        return FALSE; // not us
    if ( e->type() == QEvent::Wheel)  {
        QApplication::sendEvent(scrollbar, e);
    }
 #ifdef FAKE_CTRL_AND_ALT
    static bool control = FALSE;
    static bool alt = FALSE;
 //    qDebug(" Has a keyboard with no CTRL and ALT keys, but we fake it:");
    bool dele=FALSE;
    if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
        QKeyEvent* ke = (QKeyEvent*)e;
        bool keydown = e->type() == QEvent::KeyPress || ke->isAutoRepeat();
        switch (ke->key()) {
          case Key_F9: // let this be "Control"
              control = keydown;
              e = new QKeyEvent(QEvent::KeyPress, Key_Control, 0, ke->state());
              dele=TRUE;
              break;
          case Key_F13: // let this be "Alt"
              alt = keydown;
              e = new QKeyEvent(QEvent::KeyPress, Key_Alt, 0, ke->state());
              dele=TRUE;
              break;
          default:
              if ( control ) {
                  int a = toupper(ke->ascii())-64;
                  if ( a >= 0 && a < ' ' ) {
                      e = new QKeyEvent(e->type(), ke->key(),
                                        a, ke->state()|ControlButton, QChar(a,0));
                      dele=TRUE;
                  }
              }
              if ( alt ) {
                  e = new QKeyEvent(e->type(), ke->key(),
                                    ke->ascii(), ke->state()|AltButton, ke->text());
                  dele=TRUE;
              }
        }
    }
 #endif
    if ( e->type() == QEvent::KeyPress )  {
        QKeyEvent* ke = (QKeyEvent*)e;
        actSel=0; // Key stroke implies a screen update, so TEWidget won't
          // know where the current selection is.
 //     qDebug("key pressed is 0x%x, ascii is 0x%x, state %d", ke->key(), ke->ascii(), ke->state());
        if( ke->state() == ShiftButton && ke->key() == Key_Tab) {
          //lets hardcode this sucker
 //     qDebug("key pressed 2 is 0x%x", ke->key());
            emitText("\\"); // expose
        }
        else if( ke->state() == ControlButton && ke->key() == Key_V) {
          pasteClipboard();
        }
 //        else if( ke->state() == ControlButton && ke->key() == Key_C) {
 //          pasteClipboard();
 //        }
        else
            emit keyPressedSignal(ke); // expose
        ke->accept();
 #ifdef FAKE_CTRL_AND_ALT
        if ( dele ) delete e;
 #endif
        return true;               // stop the event
    }
    if ( e->type() == QEvent::Enter )  {
        QObject::disconnect( (QObject*)cb, SIGNAL(dataChanged()),
                             this, SLOT(onClearSelection()) );
    }
    if ( e->type() == QEvent::Leave )  {
        QObject::connect( (QObject*)cb, SIGNAL(dataChanged()),
                          this, SLOT(onClearSelection()) );
    }
    return QFrame::eventFilter( obj, e );
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                  Frame                                    */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 void TEWidget::frameChanged()
 {
  propagateSize();
  update();
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                   Sound                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 void TEWidget::Bell()
 {
-//#ifdef QT_QWS_SHARP
+//#ifdef QT_QWS_SL5XXX
 //# ifndef QT_NO_COP
    if(useBeep)
        QCopEnvelope( "QPE/TaskBar", "soundAlarm()" );
 //# endif
 //#else
 //# ifndef QT_NO_SOUND
 //    QSound::play(Resource::findSound("alarm"));
 //# endif
 //#endif
 //    QApplication::beep();
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                 Auxiluary                                 */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 void TEWidget::clearImage()
 // initialize the image
 // for internal use only
 {
  for (int y = 0; y < lines; y++)
  for (int x = 0; x < columns; x++)
  {
    image[loc(x,y)].c = 0xff; //' ';
    image[loc(x,y)].f = 0xff; //DEFAULT_FORE_COLOR;
    image[loc(x,y)].b = 0xff; //DEFAULT_BACK_COLOR;
    image[loc(x,y)].r = 0xff; //DEFAULT_RENDITION;
  }
 }
 // Create Image ///////////////////////////////////////////////////////
 void TEWidget::calcGeometry()
 {
    int showhscrollbar = 1;
    int hwidth = 0;
    int dcolumns;
    Config cfg("Konsole");
    cfg.setGroup("ScrollBar");
    useHorzScroll=cfg.readBoolEntry("HorzScroll",0);
    if(vcolumns == 0) showhscrollbar = 0;
    if(showhscrollbar == 1) hwidth = QApplication::style().scrollBarExtent().width();
    scrollbar->resize(QApplication::style().scrollBarExtent().width(),
                      contentsRect().height() - hwidth);
    switch(scrollLoc)  {
      case SCRNONE :
          columns = ( contentsRect().width() - 2 * rimX ) / font_w;
          dcolumns = columns;
          if(vcolumns) columns = vcolumns;
          blX = (contentsRect().width() - (columns*font_w) ) / 2;
          if(showhscrollbar)
              blX = -hposition * font_w;
          brX = blX;
          scrollbar->hide();
          break;
      case SCRLEFT :
          columns = ( contentsRect().width() - 2 * rimX - scrollbar->width()) / font_w;
          dcolumns = columns;
          if(vcolumns) columns = vcolumns;
          brX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
          if(showhscrollbar)
              brX = -hposition * font_w;
          blX = brX + scrollbar->width();
          scrollbar->move(contentsRect().topLeft());
          scrollbar->show();
          break;
      case SCRRIGHT:
          columns = ( contentsRect().width()  - 2 * rimX - scrollbar->width()) / font_w;
          dcolumns = columns;
          if(vcolumns) columns = vcolumns;
          blX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
          if(showhscrollbar)
              blX = -hposition * font_w;
          brX = blX;
          scrollbar->move(contentsRect().topRight() - QPoint(scrollbar->width()-1,0));
          scrollbar->show();
          break;
    }
      //FIXME: support 'rounding' styles
    lines   = ( contentsRect().height() - 2 * rimY  ) / font_h;
    bY = (contentsRect().height() - (lines  *font_h)) / 2;
    if(showhscrollbar == 1)  {
        hScrollbar->resize(contentsRect().width() - hwidth, hwidth);
        hScrollbar->setRange(0, vcolumns - dcolumns);
        QPoint p = contentsRect().bottomLeft();
        if(scrollLoc == SCRLEFT)
            hScrollbar->move(QPoint(p.x()+hwidth, p.y() - hwidth));
        else
            hScrollbar->move(QPoint(p.x(), p.y() - hwidth));
        hScrollbar->show();
    }
    else hScrollbar->hide();
    if(showhscrollbar == 1)  {
        lines = lines - (hwidth / font_h) - 1;
        if(lines < 1) lines = 1;
    }
  //FIXME: support 'rounding' styles
 }
 void TEWidget::makeImage()
 //FIXME: rename 'calcGeometry?
 {
  calcGeometry();
  image = (ca*) malloc(lines*columns*sizeof(ca));
  clearImage();
 }
 // calculate the needed size
 QSize TEWidget::calcSize(int cols, int lins) const
 {
  int frw = width() - contentsRect().width();
  int frh = height() - contentsRect().height();
  int scw = (scrollLoc==SCRNONE?0:scrollbar->width());
  return QSize( font_w*cols + 2*rimX + frw + scw, font_h*lins + 2*rimY + frh );
 }
 QSize TEWidget::sizeHint() const
 {
   return size();
 }
 void TEWidget::styleChange(QStyle &)
 {
    propagateSize();
 }
 #ifndef QT_NO_DRAGANDDROP
 /* --------------------------------------------------------------------- */
 /*                                                                       */
 /* Drag & Drop                                                           */
 /*                                                                       */
 /* --------------------------------------------------------------------- */
 void TEWidget::dragEnterEvent(QDragEnterEvent* e)
 {
  e->accept(QTextDrag::canDecode(e) ||
      QUriDrag::canDecode(e));
 }
 void TEWidget::dropEvent(QDropEvent* event)
 {
    // The current behaviour when url(s) are dropped is
    // * if there is only ONE url and if it's a LOCAL one, ask for paste or cd
    // * in all other cases, just paste
    //   (for non-local ones, or for a list of URLs, 'cd' is nonsense)
  QStrList strlist;
  int file_count = 0;
  dropText = "";
  bool bPopup = true;
  if(QUriDrag::decode(event, strlist)) {
    if (strlist.count()) {
      for(const char* p = strlist.first(); p; p = strlist.next()) {
        if(file_count++ > 0) {
          dropText += " ";
          bPopup = false; // more than one file, don't popup
        }
 /*
        KURL url(p);
        if (url.isLocalFile()) {
          dropText += url.path(); // local URL : remove protocol
        }
        else {
          dropText += url.prettyURL();
          bPopup = false; // a non-local file, don't popup
        }
 */
      }
      if (bPopup)
        // m_drop->popup(pos() + event->pos());
  m_drop->popup(mapToGlobal(event->pos()));
      else
  {
    if (currentSession) {
      currentSession->getEmulation()->sendString(dropText.local8Bit());
    }
 //    kdDebug() << "Drop:" << dropText.local8Bit() << "\n";
  }
    }
  }
  else if(QTextDrag::decode(event, dropText)) {
 //    kdDebug() << "Drop:" << dropText.local8Bit() << "\n";
    if (currentSession) {
      currentSession->getEmulation()->sendString(dropText.local8Bit());
    }
    // Paste it
  }
 }
 #endif
 void TEWidget::drop_menu_activated(int item)
 {
 #ifndef QT_NO_DRAGANDDROP
  switch (item)
  {
    case 0: // paste
      currentSession->getEmulation()->sendString(dropText.local8Bit());
 //    KWM::activate((Window)this->winId());
      break;
    case 1: // cd ...
      currentSession->getEmulation()->sendString("cd ");
      struct stat statbuf;
      if ( ::stat( QFile::encodeName( dropText ), &statbuf ) == 0 )
      {
        if ( !S_ISDIR(statbuf.st_mode) )
        {
 /*
          KURL url;
          url.setPath( dropText );
          dropText = url.directory( true, false ); // remove filename
 */
        }
      }
      dropText.replace(QRegExp(" "), "\\ "); // escape spaces
      currentSession->getEmulation()->sendString(dropText.local8Bit());
      currentSession->getEmulation()->sendString("\n");
 //    KWM::activate((Window)this->winId());
      break;
  }
 #endif
 }
 void TEWidget::setWrapAt(int columns)
 {
  vcolumns = columns;
    propagateSize();
    update();
 }
diff --git a/core/launcher/desktop.cpp b/core/launcher/desktop.cpp
index ba4fd66..59f2aea 100644
--- a/core/launcher/desktop.cpp
+++ b/core/launcher/desktop.cpp
@@ -1,301 +1,301 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <syslog.h>
 #include "desktop.h"
 #include "info.h"
 #include "launcher.h"
 #include "qcopbridge.h"
 #include "shutdownimpl.h"
 #include "startmenu.h"
 #include "taskbar.h"
 #include "transferserver.h"
 #include "irserver.h"
 #include "packageslave.h"
 #include "screensaver.h"
 #include <qpe/applnk.h>
 #include <qpe/mimetype.h>
 #include <qpe/password.h>
 #include <qpe/config.h>
 #include <qpe/power.h>
 #include <qpe/timeconversion.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/network.h>
 #include <qpe/global.h>
-#if defined( QT_QWS_SHARP ) || defined( QT_QWS_IPAQ )
+#if defined( QT_QWS_SL5XXX ) || defined( QT_QWS_IPAQ )
 #include <qpe/custom.h>
 #endif
 #include <opie/odevice.h>
 #include <qgfx_qws.h>
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qwindowsystem_qws.h>
 #include <qvaluelist.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 using namespace Opie;
 class QCopKeyRegister
 {
 public:
        QCopKeyRegister() : keyCode( 0 )
        { }
        QCopKeyRegister( int k, const QCString &c, const QCString &m )
                        : keyCode( k ), channel( c ), message( m )
        { }
        int getKeyCode() const
        {
                return keyCode;
        }
        QCString getChannel() const
        {
                return channel;
        }
        QCString getMessage() const
        {
                return message;
        }
 private:
        int keyCode;
        QCString channel, message;
 };
 typedef QValueList<QCopKeyRegister> KeyRegisterList;
 KeyRegisterList keyRegisterList;
 static Desktop* qpedesktop = 0;
 static int loggedin = 0;
 static void login( bool at_poweron )
 {
        if ( !loggedin ) {
                Global::terminateBuiltin( "calibrate" );
                Password::authenticate( at_poweron );
                loggedin = 1;
                QCopEnvelope e( "QPE/Desktop", "unlocked()" );
        }
 }
 bool Desktop::screenLocked()
 {
        return loggedin == 0;
 }
 /*
  Priority is number of alerts that are needed to pop up
  alert.
 */
 class DesktopPowerAlerter : public QMessageBox
 {
 public:
        DesktopPowerAlerter( QWidget *parent, const char *name = 0 )
                        : QMessageBox( tr( "Battery Status" ), "Low Battery",
                                       QMessageBox::Critical,
                                       QMessageBox::Ok | QMessageBox::Default,
                                       QMessageBox::NoButton, QMessageBox::NoButton,
                                       parent, name, FALSE )
        {
                currentPriority = INT_MAX;
                alertCount = 0;
        }
        void alert( const QString &text, int priority );
        void hideEvent( QHideEvent * );
 private:
        int currentPriority;
        int alertCount;
 };
 void DesktopPowerAlerter::alert( const QString &text, int priority )
 {
        alertCount++;
        if ( alertCount < priority )
                return ;
        if ( priority > currentPriority )
                return ;
        currentPriority = priority;
        setText( text );
        show();
 }
 void DesktopPowerAlerter::hideEvent( QHideEvent *e )
 {
        QMessageBox::hideEvent( e );
        alertCount = 0;
        currentPriority = INT_MAX;
 }
 void DesktopApplication::switchLCD ( bool on )
 {
        if ( qApp ) {
                DesktopApplication *dapp = (DesktopApplication *) qApp;
                if ( dapp-> m_screensaver ) {
                        if ( on ) {
                                dapp-> m_screensaver-> setDisplayState ( true );
                                dapp-> m_screensaver-> setBacklight ( -3 );
                        }
                        else {
                                dapp-> m_screensaver-> setDisplayState ( false );
                        }
                }
        }
 }
 DesktopApplication::DesktopApplication( int& argc, char **argv, Type appType )
                : QPEApplication( argc, argv, appType )
 {
        m_ps = new PowerStatus;
        m_ps_last = new PowerStatus;
        pa = new DesktopPowerAlerter( 0 );
        m_apm_timer = new QTimer ( this );
                connect ( m_apm_timer, SIGNAL( timeout ( )), this, SLOT( apmTimeout ( )));
        reloadPowerWarnSettings ( );
        m_last_button = 0;
        m_button_timer = new QTimer ( );
        connect ( m_button_timer, SIGNAL( timeout ( )), this, SLOT( sendHeldAction ( )));
        
        channel = new QCopChannel( "QPE/System", this );
        connect( channel, SIGNAL( received( const QCString&, const QByteArray& ) ),
                 this, SLOT( systemMessage( const QCString&, const QByteArray& ) ) );
        channel = new QCopChannel( "QPE/Launcher", this );
        connect( channel, SIGNAL( received( const QCString&, const QByteArray& ) ),
                 this, SLOT( launcherMessage( const QCString&, const QByteArray& ) ) );
        m_screensaver = new OpieScreenSaver ( );
        m_screensaver-> setInterval ( -1 );
        QWSServer::setScreenSaver( m_screensaver );
        rereadVolumes();
        connect( qApp, SIGNAL( volumeChanged( bool ) ), this, SLOT( rereadVolumes() ) );
        
        apmTimeout ( );
        
        grabKeyboard ( );
 }
 DesktopApplication::~DesktopApplication()
 {
        ungrabKeyboard ( );
        delete m_ps;
        delete m_ps_last;
        delete pa;
 }
 void DesktopApplication::apmTimeout()
 {
        qpedesktop-> checkMemory ( ); // in case no events are being generated
        *m_ps_last = *m_ps;
        *m_ps = PowerStatusManager::readStatus();
        if ( m_ps-> acStatus ( ) != m_ps_last-> acStatus ( ))
                m_screensaver-> powerStatusChanged ( *m_ps );
        if ( m_ps-> acStatus ( ) != PowerStatus::Online ) {
                int bat = m_ps-> batteryPercentRemaining ( );
                if ( bat < m_ps_last-> batteryPercentRemaining ( )) {
                        if ( bat <= m_powerCritical )
                                pa->alert( tr( "Battery level is critical!\nKeep power off until power restored!" ), 1 );
                        else if ( bat <= m_powerVeryLow )
                                pa->alert( tr( "Battery is running very low." ), 2 );
                }
                if ( m_ps-> backupBatteryStatus ( ) == PowerStatus::VeryLow )
                        pa->alert( tr( "The Back-up battery is very low.\nPlease charge the back-up battery." ), 2 );
        }
 }
 void DesktopApplication::systemMessage( const QCString & msg, const QByteArray & data )
 {
        QDataStream stream ( data, IO_ReadOnly );
        if ( msg == "setScreenSaverInterval(int)" ) {
                int time;
                stream >> time;
                m_screensaver-> setInterval( time );
        }
        else if ( msg == "setScreenSaverIntervals(int,int,int)" ) {
                int t1, t2, t3;
                stream >> t1 >> t2 >> t3;
                m_screensaver-> setIntervals( t1, t2, t3 );
        }
        else if ( msg == "setBacklight(int)" ) {
                int bright;
                stream >> bright;
                m_screensaver-> setBacklight( bright );
        }
        else if ( msg == "setScreenSaverMode(int)" ) {
                int mode;
                stream >> mode;
                m_screensaver-> setMode ( mode );
        }
        else if ( msg == "reloadPowerWarnSettings()" ) {
                reloadPowerWarnSettings();
        }
        else if ( msg == "setDisplayState(int)" ) {
                int state;
                stream >> state;
                m_screensaver-> setDisplayState ( state != 0 );
        }
        else if ( msg == "suspend()" ) {
                emit power();
        }
        else if ( msg == "sendBusinessCard()" ) {
                QString card = ::getenv ( "HOME" );
                card += "/Applications/addressbook/businesscard.vcf";
                if ( QFile::exists( card ) ) {
                        QCopEnvelope e ( "QPE/Obex", "send(QString,QString,QString)" );
                        QString mimetype = "text/x-vCard";
                        e << tr( "business card" ) << card << mimetype;
                }
        }
 }
 void DesktopApplication::reloadPowerWarnSettings ( )
 {
        Config cfg ( "apm" );
        cfg. setGroup ( "Warnings" );
        int iv = cfg. readNumEntry ( "checkinterval", 10000 );
                m_apm_timer-> stop ( );
diff --git a/core/launcher/main.cpp b/core/launcher/main.cpp
index 49b41d6..8eaea17 100644
--- a/core/launcher/main.cpp
+++ b/core/launcher/main.cpp
@@ -1,177 +1,177 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "desktop.h"
 #include "taskbar.h"
 #include "stabmon.h"
 #include <qpe/qpeapplication.h>
 #include <qpe/network.h>
 #include <qpe/config.h>
-#if defined( QT_QWS_SHARP ) || defined( QT_QWS_IPAQ )
+#if defined( QT_QWS_SL5XXX ) || defined( QT_QWS_IPAQ )
 #include <qpe/custom.h>
 #endif
 #include <opie/odevice.h>
 #include <qmessagebox.h>
 #include <qfile.h>
 #include <qimage.h>
 #include <qwindowsystem_qws.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/alarmserver.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <signal.h>
 #include <unistd.h>
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
 #include "../calibrate/calibrate.h"
 #endif
 using namespace Opie;
 void initEnvironment()
 {
  Config config("locale");
  config.setGroup( "Location" );
  QString tz = config.readEntry( "Timezone", getenv("TZ") );
  // if not timezone set, pick New York
  if (tz.isNull())
      tz = "America/New_York";
  setenv( "TZ", tz, 1 );
  config.writeEntry( "Timezone", tz);
  config.setGroup( "Language" );
  QString lang = config.readEntry( "Language", getenv("LANG") );
  if ( !lang.isNull() )
    setenv( "LANG", lang, 1 );
 }
 int initApplication( int argc, char ** argv )
 {
    initEnvironment();
-#if !defined(QT_QWS_CASSIOPEIA) && !defined(QT_QWS_IPAQ) && !defined(QT_QWS_EBX)
+#if !defined(QT_QWS_CASSIOPEIA) && !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX)
    setenv( "QWS_SIZE", "240x320", 0 );
 #endif
    //Don't flicker at startup:
    QWSServer::setDesktopBackground( QImage() );
    DesktopApplication a( argc, argv, QApplication::GuiServer );
        ODevice::inst ( )-> setSoftSuspend ( true );
        { // init backlight
            QCopEnvelope e("QPE/System", "setBacklight(int)" );
            e << -3; // Forced on
        }
    AlarmServer::initialize();
    Desktop *d = new Desktop();
    QObject::connect( &a, SIGNAL(power()),   d, SLOT(togglePower()) );
    QObject::connect( &a, SIGNAL(backlight()),   d, SLOT(toggleLight()) );
    QObject::connect( &a, SIGNAL(symbol()),   d, SLOT(toggleSymbolInput()) );
    QObject::connect( &a, SIGNAL(numLockStateToggle()),   d, SLOT(toggleNumLockState()) );
    QObject::connect( &a, SIGNAL(capsLockStateToggle()),   d, SLOT(toggleCapsLockState()) );
    QObject::connect( &a, SIGNAL(prepareForRestart()),   d, SLOT(terminateServers()) );
    (void)new SysFileMonitor(d);
    Network::createServer(d);
-#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
    if ( !QFile::exists( "/etc/pointercal" ) ) {
        // Make sure calibration widget starts on top.
        Calibrate *cal = new Calibrate;
        cal->exec();
        delete cal;
    }
 #endif
    d->show();
        if ( QDate::currentDate ( ). year ( ) < 2000 ) {
                if ( QMessageBox::information ( 0, DesktopApplication::tr( "Information" ), DesktopApplication::tr( "<p>The system date doesn't seem to be valid.\n(%1)</p><p>Do you want to correct the clock ?</p>" ). arg( TimeString::dateString ( QDate::currentDate ( ))), QMessageBox::Yes, QMessageBox::No ) == QMessageBox::Yes ) {
                        QCopEnvelope e ( "QPE/Application/systemtime", "setDocument(QString)" );
                                e << QString ( );                                     
                }
        }
    int rv =  a.exec();
    delete d;
        ODevice::inst ( )-> setSoftSuspend ( false );
    return rv;
 }
 static const char *pidfile_path = "/var/run/opie.pid";
 void create_pidfile ( )
 {
        FILE *f;
        if (( f = ::fopen ( pidfile_path, "w" ))) {
                ::fprintf ( f, "%d", getpid ( ));
                ::fclose ( f );
        }
 }
 void remove_pidfile ( )
 {
        ::unlink ( pidfile_path );
 }
 void handle_sigterm ( int /* sig */ )
 {
        if ( qApp )
                qApp-> quit ( );
 }
 int main( int argc, char ** argv )
 {
    ::signal ( SIGCHLD, SIG_IGN );
        ::signal ( SIGTERM, handle_sigterm );
        ::signal ( SIGINT, handle_sigterm );
        ::setsid ( );
        ::setpgid ( 0, 0 );
        ::atexit ( remove_pidfile );
        create_pidfile ( );
    int retVal = initApplication ( argc, argv );
    // Kill them. Kill them all.
    ::kill ( 0, SIGTERM );
    ::sleep ( 1 );
    ::kill ( 0, SIGKILL );
    return retVal;
 }
diff --git a/core/launcher/taskbar.cpp b/core/launcher/taskbar.cpp
index 77035a3..8af568d 100644
--- a/core/launcher/taskbar.cpp
+++ b/core/launcher/taskbar.cpp
@@ -1,341 +1,341 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 *********************************************************************/
 #include "startmenu.h"
 #include "inputmethods.h"
 #include "runningappbar.h"
 #include "systray.h"
 #include "calibrate.h"
 #include "wait.h"
 #include "appicons.h"
 #include "taskbar.h"
 #include "desktop.h"
 #include <qpe/qpeapplication.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/global.h>
-#if defined( QT_QWS_SHARP ) || defined( QT_QWS_IPAQ )
+#if defined( QT_QWS_SL5XXX ) || defined( QT_QWS_IPAQ )
 #include <qpe/custom.h>
 #endif
 #include <opie/odevice.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qtimer.h>
 #include <qwindowsystem_qws.h>
 #include <qwidgetstack.h>
 #if defined( Q_WS_QWS )
 #include <qwsdisplay_qws.h>
 #include <qgfx_qws.h>
 #endif
 using namespace Opie;
 #define FACTORY(T) \
    static QWidget *new##T( bool maximized ) { \
  QWidget *w = new T( 0, "test", QWidget::WDestructiveClose | QWidget::WGroupLeader ); \
  if ( maximized ) { \
      if ( qApp->desktop()->width() <= 350 ) { \
    w->showMaximized(); \
      } else { \
    w->resize( QSize( 300, 300 ) ); \
      } \
  } \
  w->show(); \
  return w; \
    }
 #ifdef SINGLE_APP
 #define APP(a,b,c,d) FACTORY(b)
 #include "../launcher/apps.h"
 #undef APP
 #endif // SINGLE_APP
 static Global::Command builtins[] = {
 #ifdef SINGLE_APP
 #define APP(a,b,c,d) { a, new##b, c },
 #include "../launcher/apps.h"
 #undef APP
 #endif
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_SHARP)
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_SL5XXX)
        { "calibrate",          TaskBar::calibrate, 1, 0 },
 #endif
 #if !defined(QT_QWS_CASSIOPEIA)
  { "shutdown",           Global::shutdown,   1, 0 },
 //  { "run",                run,      1, 0 },
 #endif
  { 0,            TaskBar::calibrate, 0, 0 },
 };
 static bool initNumLock()
 {
 #ifdef QPE_INITIAL_NUMLOCK_STATE
    QPE_INITIAL_NUMLOCK_STATE
 #endif
    return FALSE;
 }
 class LockKeyState : public QWidget
 {
 public:
    LockKeyState( QWidget *parent ) :
  QWidget(parent),
  nl(initNumLock()), cl(FALSE)
    {
  nl_pm = Resource::loadPixmap("numlock");
  cl_pm = Resource::loadPixmap("capslock");
    }
    QSize sizeHint() const
    {
  return QSize(nl_pm.width()+2,nl_pm.width()+nl_pm.height()+1);
    }
    void toggleNumLockState()
    {
  nl = !nl; repaint();
    }
    void toggleCapsLockState()
    {
  cl = !cl; repaint();
    }
    void paintEvent( QPaintEvent * )
    {
  int y = (height()-sizeHint().height())/2;
  QPainter p(this);
  if ( nl )
      p.drawPixmap(1,y,nl_pm);
  if ( cl )
      p.drawPixmap(1,y+nl_pm.height()+1,cl_pm);
    }
 private:
    QPixmap nl_pm, cl_pm;
    bool nl, cl;
 };
 TaskBar::~TaskBar()
 {
 }
 TaskBar::TaskBar() : QHBox(0, 0, WStyle_Customize | WStyle_Tool | WStyle_StaysOnTop | WGroupLeader)
 {
    Global::setBuiltinCommands(builtins);
    sm = new StartMenu( this );
    inputMethods = new InputMethods( this );
    connect( inputMethods, SIGNAL(inputToggled(bool)),
       this, SLOT(calcMaxWindowRect()) );
    //new QuickLauncher( this );
    stack = new QWidgetStack( this );
    stack->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
    label = new QLabel(stack);
    //mru = new MRUList( stack );
    //stack->raiseWidget( mru );
    runningAppBar = new RunningAppBar(stack);
    stack->raiseWidget(runningAppBar);
    waitIcon = new Wait( this );
    (void) new AppIcons( this );
    sysTray = new SysTray( this );
    // ## make customizable in some way? 
    lockState = new LockKeyState( this );
 #if defined(Q_WS_QWS)
 #if !defined(QT_NO_COP)
    QCopChannel *channel = new QCopChannel( "QPE/TaskBar", this );
    connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
  this, SLOT(receive(const QCString&, const QByteArray&)) );
 #endif
 #endif
    waitTimer = new QTimer( this );
    connect( waitTimer, SIGNAL( timeout() ), this, SLOT( stopWait() ) );
    clearer = new QTimer( this );
    QObject::connect(clearer, SIGNAL(timeout()), SLOT(clearStatusBar()));
    QObject::connect(clearer, SIGNAL(timeout()), sysTray, SLOT(show()));
 }
 void TaskBar::setStatusMessage( const QString &text )
 {
    if ( !text.isEmpty() ) {
        label->setText( text );
        stack->raiseWidget( label );
        if ( sysTray && ( label->fontMetrics().width( text ) > label->width() ) )
            sysTray->hide();
        clearer->start( 3000, TRUE );
    } else {
        clearStatusBar();
    }
 }
 void TaskBar::clearStatusBar()
 {
    label->clear();
    stack->raiseWidget(runningAppBar);
     //  stack->raiseWidget( mru );
 }
 void TaskBar::startWait()
 {
    waitIcon->setWaiting( true );
    // a catchall stop after 10 seconds...
    waitTimer->start( 10 * 1000, true );
 }
 void TaskBar::stopWait(const QString& /*app*/)
 {
    waitTimer->stop();
    //mru->addTask(sm->execToLink(app));
    waitIcon->setWaiting( false );
 }
 void TaskBar::stopWait()
 {
    waitTimer->stop();
    waitIcon->setWaiting( false );
 }
 void TaskBar::resizeEvent( QResizeEvent *e )
 {
    QHBox::resizeEvent( e );
    calcMaxWindowRect();
 }
 void TaskBar::styleChange( QStyle &s )
 {
    QHBox::styleChange( s );
    calcMaxWindowRect();
 }
 void TaskBar::calcMaxWindowRect()
 {
 #ifdef Q_WS_QWS
    QRect wr;
    int displayWidth  = qApp->desktop()->width();
    QRect ir = inputMethods->inputRect();
    if ( ir.isValid() ) {
  wr.setCoords( 0, 0, displayWidth-1, ir.top()-1 );
    } else {
  wr.setCoords( 0, 0, displayWidth-1, y()-1 );
    }
 #if QT_VERSION < 300
    QWSServer::setMaxWindowRect( qt_screen->mapToDevice(wr,
  QSize(qt_screen->width(),qt_screen->height()))
  );
 #else
    QWSServer::setMaxWindowRect( wr );
 #endif
 #endif
 }
 void TaskBar::receive( const QCString &msg, const QByteArray &data )
 {
        QDataStream stream( data, IO_ReadOnly );
        if ( msg == "message(QString)" ) {
                QString text;
                stream >> text;
                setStatusMessage( text );
        } else if ( msg == "hideInputMethod()" ) {
                inputMethods->hideInputMethod();
        } else if ( msg == "showInputMethod()" ) {
                inputMethods->showInputMethod();
        } else if ( msg == "reloadInputMethods()" ) {
                inputMethods->loadInputMethods();
        } else if ( msg == "reloadApps()" ) {
                        sm->reloadApps();               
        } else if ( msg == "reloadApplets()" ) {
                sysTray->clearApplets();
                sysTray->addApplets();
                sm->reloadApplets();
        } else if ( msg == "soundAlarm()" ) {
                DesktopApplication::soundAlarm ( );
        }
        else if ( msg == "setLed(int,bool)" ) {
                int led, status;
                stream >> led >> status;
                QValueList <OLed> ll = ODevice::inst ( )-> ledList ( );
                        if ( ll. count ( )){
                        OLed l = ll. contains ( Led_Mail ) ? Led_Mail : ll [0];
                        bool canblink = ODevice::inst ( )-> ledStateList ( l ). contains ( Led_BlinkSlow );
                        
                        ODevice::inst ( )-> setLedState ( l, status ? ( canblink ? Led_BlinkSlow : Led_On ) : Led_Off );
                }
        }
        else if ( msg == "toggleMenu()" ) {
                if ( sm-> launchMenu-> isVisible ( ))
                        sm-> launch ( );
                else {
                        QCopEnvelope e ( "QPE/System", "toggleApplicationMenu()" );
                }
        }
        else if ( msg == "toggleStartMenu()" ) {
                sm-> launch ( );
        }
 }
 QWidget *TaskBar::calibrate(bool)
 {
 #ifdef Q_WS_QWS
    Calibrate *c = new Calibrate;
    c->show();
    return c;
 #else
    return 0;
 #endif
 }
 void TaskBar::toggleNumLockState()
 {
    if ( lockState ) lockState->toggleNumLockState();
 }
 void TaskBar::toggleCapsLockState()
 {
    if ( lockState ) lockState->toggleCapsLockState();
 }
 void TaskBar::toggleSymbolInput()
 {
    if ( inputMethods->currentShown() == "Unicode" ) {
  inputMethods->hideInputMethod();
    } else {
  inputMethods->showInputMethod("Unicode");
    }
 }
 bool TaskBar::recoverMemory()
 {
    //eturn mru->quitOldApps();
diff --git a/core/multimedia/opieplayer/loopcontrol_threaded.cpp b/core/multimedia/opieplayer/loopcontrol_threaded.cpp
index 1b89bc8..6817d5b 100644
--- a/core/multimedia/opieplayer/loopcontrol_threaded.cpp
+++ b/core/multimedia/opieplayer/loopcontrol_threaded.cpp
@@ -1,298 +1,298 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #define _REENTRANT
 #include <qpe/qpeapplication.h>
 #include <qimage.h>
 #include <qpainter.h>
 #ifdef Q_WS_QWS
 #include <qpe/qcopenvelope_qws.h>
 #endif
 #include "mediaplayerplugininterface.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include <pthread.h>
 #include "loopcontrol.h"
 #include "audiodevice.h"
 #include "videowidget.h"
 #include "audiowidget.h"
 #include "mediaplayerstate.h"
-#if defined(QT_QWS_SHARP) || defined(QT_QWS_IPAQ)
+#if defined(QT_QWS_SL5XXX) || defined(QT_QWS_IPAQ)
 #define USE_REALTIME_AUDIO_THREAD
 #endif
 extern VideoWidget *videoUI; // now only needed to tell it to play a frame
 extern MediaPlayerState *mediaPlayerState;
 #define DecodeLoopDebug(x)  qDebug x
 //#define DecodeLoopDebug(x)
        static char    *audioBuffer = NULL;
 static AudioDevice  *audioDevice = NULL;
        static bool    disabledSuspendScreenSaver = FALSE;
        pthread_tvideo_tid;
 pthread_attr_t  video_attr;
        pthread_taudio_tid;
 pthread_attr_t  audio_attr;
 bool emitPlayFinished = FALSE;
 bool emitChangePos = FALSE;
 class Mutex {
 public:
    Mutex() {
        pthread_mutexattr_t attr;
        pthread_mutexattr_init( &attr );
        pthread_mutex_init( &mutex, &attr );
        pthread_mutexattr_destroy( &attr );
    }
    ~Mutex() {
        pthread_mutex_destroy( &mutex );
    }
    void lock() {
        pthread_mutex_lock( &mutex );
    }
    void unlock() {
        pthread_mutex_unlock( &mutex );
    }
 /*
    bool locked() {
        switch ( pthread_mutex_trylock( &mutex ) ) {
            case EBUSY:
                return TRUE;
            case 0:
                pthread_mutex_unlock( &mutex );
            default:
                return FALSE;
        }
    }
 */
 private:
    pthread_mutex_t mutex;
 };
 class currentFrameObj {
 public:
    currentFrameObj() : value( 0 ) { }
    void set( long f ) {
        mutex.lock();
        value = f;
        mediaPlayerState->curDecoder()->videoSetFrame( f, 0 );
        mutex.unlock();
    }
    long get() {
        return value;
    }
 private:
    long value;
    Mutex mutex;
 };
 Mutex *videoMutex;
 Mutex *audioMutex;
 Mutex *globalMutex;
        clock_tbegin;
 LoopControl::LoopControl( QObject *parent, const char *name )
    : QObject( parent, name ) {
    isMuted = FALSE;
    connect( qApp, SIGNAL( volumeChanged(bool) ), this, SLOT( setMute(bool) ) );
    timerid = startTimer( 200 );
    videoMutex = new Mutex;
    audioMutex = new Mutex;
    globalMutex = new Mutex;
    //begin = clock();
 }
 LoopControl::~LoopControl() {
    stop();
    killTimer( timerid );
 }
 static bool sendingNewPos = FALSE;
 static long prev_frame = 0;
 static int currentSample = 0;
 void LoopControl::timerEvent( QTimerEvent* ) {
    // We need to emit playFinished from the main thread, not one of the
    // decoding threads else we'll have all kinds of yucky things happen (reentrance).
    // playFinished will eventually call stop() which stops these threads.
    if ( emitPlayFinished ) {
        emitPlayFinished = FALSE;
        mediaPlayerState->setPlaying( FALSE );
    }
    if ( emitChangePos ) {
        emitChangePos = FALSE;
        if ( hasVideoChannel && hasAudioChannel ) {
            sendingNewPos = TRUE;
            mediaPlayerState->setPosition( current_frame );
        } else if ( hasVideoChannel ) {
            sendingNewPos = TRUE;
            mediaPlayerState->setPosition( current_frame );
        } else if ( hasAudioChannel ) {
            sendingNewPos = TRUE;
            mediaPlayerState->setPosition( audioSampleCounter );
        }
    }
 }
 void LoopControl::setPosition( long pos ) {
    if ( sendingNewPos ) {
        sendingNewPos = FALSE;
        return;
    }
    if ( hasVideoChannel && hasAudioChannel ) {
        videoMutex->lock();
        audioMutex->lock();
 qDebug("setting position");
        playtime.restart();
        playtime = playtime.addMSecs( -pos * 1000 / framerate );
        //begin = clock() - (double)pos * CLOCKS_PER_SEC / framerate;
        current_frame = pos + 1;
        mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
        prev_frame = current_frame - 1;
        currentSample = (int)( current_frame * freq / framerate );
        mediaPlayerState->curDecoder()->audioSetSample( currentSample, stream );
        audioSampleCounter = currentSample - 1;
        audioMutex->unlock();
        videoMutex->unlock();
    } else if ( hasVideoChannel ) {
        videoMutex->lock();
        playtime.restart();
        playtime = playtime.addMSecs( -pos * 1000 / framerate );
        //begin = clock() - (double)pos * CLOCKS_PER_SEC / framerate;
        current_frame = pos + 1;
        mediaPlayerState->curDecoder()->videoSetFrame( current_frame, stream );
        videoMutex->unlock();
        prev_frame = current_frame - 1;
    } else if ( hasAudioChannel ) {
        audioMutex->lock();
        playtime.restart();
        playtime = playtime.addMSecs( -pos * 1000 / freq );
        //begin = clock() - (double)pos * CLOCKS_PER_SEC / freq;
        currentSample = pos + 1; // (int)( current_frame * freq / framerate );
        mediaPlayerState->curDecoder()->audioSetSample( currentSample, stream );
        audioSampleCounter = currentSample - 1;
        audioMutex->unlock();
    }
 }
 void *startVideoThread( void *ptr ) {
    LoopControl *mpegView = (LoopControl *)ptr;
    mpegView->startVideo();
    return 0;
 }
 void *startAudioThread( void *ptr ) {
    LoopControl *mpegView = (LoopControl *)ptr;
    mpegView->startAudio();
    return 0;
 }
 void LoopControl::startVideo() {
    moreVideo = TRUE;
    while ( moreVideo ) {
        if ( mediaPlayerState->curDecoder() && hasVideoChannel ) {
            if ( hasAudioChannel && !isMuted ) {
                bool done = FALSE;
                do {
 /*
                    videoMutex->lock();
                    current_frame = int( (double)playtime.elapsed() * (double)framerate / 1000.0 );
                    //current_frame = ( clock() - begin ) * (double)framerate / CLOCKS_PER_SEC;
        
                    // Sync to Audio
        //          current_frame = (long)((double)(audioSampleCounter - 1000) * framerate / (double)freq);
                    long mSecsToNextFrame = 0;
                    if ( current_frame == prev_frame ) {
                        int nf = current_frame + 1;
                        if ( nf > 0 && nf != total_video_frames )
                            // mSecsToNextFrame = long(double(nf * CLOCKS_PER_SEC) / framerate) - ( clock() - begin );
                            mSecsToNextFrame = long(double(nf * 1000) / framerate) - ( playtime.elapsed() );
                    }
                    videoMutex->unlock();
                    if ( mSecsToNextFrame ) {
                        usleep( mSecsToNextFrame ); // wait a bit
                        videoMutex->lock();
                        // This should now be the next frame
                        current_frame = int( (double)playtime.elapsed() * (double)framerate / 1000.0 );
                        //current_frame = ( clock() - begin ) * (double)framerate / CLOCKS_PER_SEC;
                        videoMutex->unlock();
                    }
                    videoMutex->lock();
                    done = current_frame >= prev_frame;
                    videoMutex->unlock();
 */
                    videoMutex->lock();
                    current_frame = int( (double)playtime.elapsed() * (double)framerate / 1000.0 );
                    done = current_frame >= prev_frame;
                    videoMutex->unlock();
                    if ( !done )
                        usleep( 1000 ); // wait a bit
                } while ( !done );
        //      qDebug("elapsed: %i %i (%f)", int( playtime.elapsed() ), current_frame, framerate );
            } else {
diff --git a/core/opie-login/main.cpp b/core/opie-login/main.cpp
index 81f4d1e..1800be0 100644
--- a/core/opie-login/main.cpp
+++ b/core/opie-login/main.cpp
@@ -70,299 +70,299 @@ static struct option long_options [] = {
        { 0, 0, 0, 0 }
 };
 int main ( int argc, char **argv )
 {
        pid_t ppid = ::getpid ( );
        if ( ::geteuid ( ) != 0 ) {
                ::fprintf ( stderr, "%s can only be executed by root. (or chmod +s)", argv [0] );
                return 1;
        }
        if ( ::getuid ( ) != 0 ) // qt doesn't really like SUID and
                ::setuid ( 0 );      // messes up things like config files
        char *autolog = 0;
        int c;
        while (( c = ::getopt_long ( argc, argv, "a:", long_options, 0 )) != -1 ) {
                switch ( c ) {
                        case 'a':
                                autolog = optarg;
                                break;
                        default:
                                ::fprintf ( stderr, "Usage: %s [-a|--autologin=<user>]\n", argv [0] );
                                return 2;
                }
        }
        //struct rlimit rl;
        //::getrlimit ( RLIMIT_NOFILE, &rl );
        //for ( unsigned int i = 0; i < rl. rlim_cur; i++ )
        //      ::close ( i );
        ::setpgid ( 0, 0 );
        ::setsid ( );
                ::signal ( SIGTERM, sigterm );
        ::signal ( SIGINT, sigterm );
        ::openlog ( "opie-login", LOG_CONS, LOG_AUTHPRIV );
        ::atexit ( exit_closelog );
        while ( true ) {
                pid_t child = ::fork ( );
                if ( child < 0 ) {
                        ::syslog ( LOG_ERR, "Could not fork GUI process\n" );
                        break;
                }
                else if ( child > 0 ) {
                        int status = 0;
                        time_t started = ::time ( 0 );
                        while ( ::waitpid ( child, &status, 0 ) < 0 ) { }
                        LoginApplication::logout ( );
                        if (( ::time ( 0 ) - started ) < 3 ) {
                                if ( autolog ) {
                                        ::syslog ( LOG_ERR, "Respawning too fast -- disabling auto-login\n" );
                                        autolog = 0;
                                }
                                else {
                                        ::syslog ( LOG_ERR, "Respawning too fast -- going down\n" );
                                        break;
                                }
                        }
                        int killedbysig = 0;
                        if ( WIFSIGNALED( status )) {
                                switch ( WTERMSIG( status )) {
                                        case SIGINT :
                                        case SIGTERM:
                                        case SIGKILL:
                                                break;
                                        default     :
                                                killedbysig = WTERMSIG( status );
                                                break;
                                }
                        }
                        if ( killedbysig ) {  // qpe was killed by an uncaught signal
                                qApp = 0;
                                
                                ::syslog ( LOG_ERR, "Opie was killed by a signal #%d", killedbysig );
                                QWSServer::setDesktopBackground ( QImage ( ));
                                QApplication *app = new QApplication ( argc, argv, QApplication::GuiServer );
                                app-> setFont ( QFont ( "Helvetica", 10 ));
                                app-> setStyle ( new QPEStyle ( ));
                                const char *sig = ::strsignal ( killedbysig );
                                QLabel *l = new QLabel ( 0, "sig", Qt::WStyle_Customize | Qt::WStyle_NoBorder | Qt::WStyle_Tool );
                                l-> setText ( LoginWindowImpl::tr( "OPIE was terminated\nby an uncaught signal\n(%1)\n" ). arg ( sig ));
                                l-> setAlignment ( Qt::AlignCenter );
                                l-> move ( 0, 0 );
                                l-> resize ( app-> desktop ( )-> width ( ), app-> desktop ( )-> height ( ));
                                l-> show ( );
                                QTimer::singleShot ( 3000, app, SLOT( quit ( )));
                                app-> exec ( );
                                delete app;
                                qApp = 0;
                        }
                }
                else {
                        if ( !autolog ) {
                                Config cfg ( "opie-login" );
                                cfg. setGroup ( "General" );
                                QString user = cfg. readEntry ( "AutoLogin" );
                                
                                if ( !user. isEmpty ( ))
                                        autolog = ::strdup ( user. latin1 ( ));
                        }
                
                        if ( autolog ) {
                                LoginApplication::setLoginAs ( autolog );
                                if ( LoginApplication::changeIdentity ( ))
                                        ::exit ( LoginApplication::login ( ));
                                else
                                        ::exit ( 0 );
                        }
                        else 
                                ::exit ( login_main ( argc, argv, ppid ));
                }
        }
        return 0;
 }
 void sigterm ( int /*sig*/ )
 {
        ::exit ( 0 );
 }
 void exit_closelog ( )
 {
        ::closelog ( );
 }
 class LoginScreenSaver : public QWSScreenSaver
 {
 public:
  LoginScreenSaver ( )
  {
    m_lcd_status = true;
    m_backlight_bright = -1;
    m_backlight_forcedoff = false;
    // Make sure the LCD is in fact on, (if opie was killed while the LCD is off it would still be off)
    ODevice::inst ( )-> setDisplayStatus ( true );
  }
  void restore()
  {
    if ( !m_lcd_status )     // We must have turned it off
      ODevice::inst ( ) -> setDisplayStatus ( true );
    setBacklight ( -3 );
  }
  bool save( int level )
  {
    switch ( level ) {
      case 0:
        if ( backlight() > 1 )
          setBacklight( 1 ); // lowest non-off
        return true;
        break;
      case 1:
        setBacklight( 0 ); // off
        return true;
        break;
      case 2:
        // We're going to suspend the whole machine
        if ( PowerStatusManager::readStatus().acStatus() != PowerStatus::Online ) {
          QWSServer::sendKeyEvent( 0xffff, Qt::Key_F34, FALSE, TRUE, FALSE );
          return true;
        }
        break;
    }
    return false;
  }
 private:
 public:
  void setIntervals( int i1 = 30, int i2 = 20, int i3 = 60 )
  {
    int v [4];
    v [ 0 ] = QMAX( 1000 * i1, 100 );
    v [ 1 ] = QMAX( 1000 * i2, 100 );
    v [ 2 ] = QMAX( 1000 * i3, 100 );
    v [ 3 ] = 0;
    if ( !i1 && !i2 && !i3 )
      QWSServer::setScreenSaverInterval ( 0 );
    else
      QWSServer::setScreenSaverIntervals ( v );
  }
  int backlight ( )
  {
    if ( m_backlight_bright == -1 )
      m_backlight_bright = 255;
    return m_backlight_bright;
  }
  void setBacklight ( int bright )
  {
    if ( bright == -3 ) {
      // Forced on
      m_backlight_forcedoff = false;
      bright = -1;
    }
    if ( m_backlight_forcedoff && bright != -2 )
      return ;
    if ( bright == -2 ) {
      // Toggle between off and on
      bright = m_backlight_bright ? 0 : -1;
      m_backlight_forcedoff = !bright;
    }
    m_backlight_bright = bright;
    bright = backlight ( );
    ODevice::inst ( ) -> setDisplayBrightness ( bright );
    m_backlight_bright = bright;
  }
 private:
  bool m_lcd_status;
  int m_backlight_bright;
  bool m_backlight_forcedoff;
 };
 namespace Opie { extern int force_appearance; }  // HACK to get around the force-style setting
 int login_main ( int argc, char **argv, pid_t ppid )
 {
        QWSServer::setDesktopBackground( QImage() );
        LoginApplication *app = new LoginApplication ( argc, argv, ppid );
        Opie::force_appearance = 0;
        app-> setFont ( QFont ( "Helvetica", 10 ));
        app-> setStyle ( new QPEStyle ( ));
        ODevice::inst ( )-> setSoftSuspend ( true );
-#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
        if ( !QFile::exists ( "/etc/pointercal" )) {
                // Make sure calibration widget starts on top.
                Calibrate *cal = new Calibrate;
                cal-> exec ( );
                delete cal;
        }
 #endif
        LoginScreenSaver *saver = new LoginScreenSaver;
        saver-> setIntervals ( );
        QWSServer::setScreenSaver ( saver );
        saver-> restore ( );
        LoginWindowImpl *lw = new LoginWindowImpl ( );
        app-> setMainWidget ( lw );
        lw-> setGeometry ( 0, 0, app-> desktop ( )-> width ( ), app-> desktop ( )-> height ( ));
        lw-> show ( );
        int rc = app-> exec ( );
        ODevice::inst ( )-> setSoftSuspend ( false );
        if ( app-> loginAs ( )) {
                if ( app-> changeIdentity ( )) {
                        app-> login ( );
                        // if login succeeds, it never comes back
                        QMessageBox::critical ( 0, LoginWindowImpl::tr( "Failure" ), LoginWindowImpl::tr( "Could not start OPIE." ));
                        rc = 1;
                }
                else {
                        QMessageBox::critical ( 0, LoginWindowImpl::tr( "Failure" ), LoginWindowImpl::tr( "Could not switch to new user identity" ));
                        rc = 2;
                }
        }
        return rc;
 }
diff --git a/library/power.cpp b/library/power.cpp
index 21c8960..5310b47 100644
--- a/library/power.cpp
+++ b/library/power.cpp
@@ -1,171 +1,171 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "power.h"
-#ifdef QT_QWS_SHARP
+#ifdef QT_QWS_SL5XXX
 #include "custom.h"
 #endif
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #ifdef QT_QWS_IPAQ_NO_APM
 #include <linux/h3600_ts.h>
 #endif
 PowerStatusManager *PowerStatusManager::powerManager = 0;
 PowerStatus *PowerStatusManager::ps = 0;
 static bool haveProcApm = false;
 PowerStatusManager::PowerStatusManager()
 {
    powerManager = this;
    ps = new PowerStatus;
    FILE *f = fopen("/proc/apm", "r");
    if ( f ) {
        fclose(f);
        haveProcApm = TRUE;
    }
 }
 const PowerStatus &PowerStatusManager::readStatus()
 {
    if ( !powerManager )
        (void)new PowerStatusManager;
    powerManager->getStatus();
    return *ps;
 }
 // Standard /proc/apm reader
 bool PowerStatusManager::getProcApmStatus( int &ac, int &bs, int &bf, int &pc, int &sec )
 {
    bool ok = false;
    ac = 0xff;
    bs = 0xff;
    bf = 0xff;
    pc = -1;
    sec = -1;
    FILE *f = fopen("/proc/apm", "r");
    if ( f ) {
        //I 1.13 1.2 0x02 0x00 0xff 0xff 49% 147 sec
        char u;
        fscanf(f, "%*[^ ] %*d.%*d 0x%*x 0x%x 0x%x 0x%x %d%% %i %c",
                &ac, &bs, &bf, &pc, &sec, &u);
        fclose(f);
        switch ( u ) {
            case 'm': sec *= 60;
            case 's': break; // ok
            default: sec = -1; // unknown
        }
        // extract data
        switch ( bs ) {
            case 0x00:
                ps->bs = PowerStatus::High;
                break;
            case 0x01:
                ps->bs = PowerStatus::Low;
                break;
            case 0x7f:
                ps->bs = PowerStatus::VeryLow;
                break;
            case 0x02:
                ps->bs = PowerStatus::Critical;
                break;
            case 0x03:
                ps->bs = PowerStatus::Charging;
                break;
            case 0x04:
            case 0xff: // 0xff is Unknown but we map to NotPresent
            default:
                ps->bs = PowerStatus::NotPresent;
                break;
        }
        switch ( ac ) {
            case 0x00:
                ps->ac = PowerStatus::Offline;
                break;
            case 0x01:
                ps->ac = PowerStatus::Online;
                break;
            case 0x02:
                ps->ac = PowerStatus::Backup;
                break;
        }
        if ( pc > 100 ) pc = 100;
        if ( pc < 0 ) pc = 0;
        ps->percentRemain = pc;
        ps->secsRemain = sec;
        ok = true;
    }
    return ok;
 }
 void PowerStatusManager::getStatus()
 {
    bool usedApm = FALSE;
    ps->percentAccurate = TRUE;
    // Some iPAQ kernel builds don't have APM. If this is not the case we
    // save ourselves an ioctl by testing if /proc/apm exists in the
    // constructor and we use /proc/apm instead
    int ac, bs, bf, pc, sec;
    if ( haveProcApm )
        usedApm = getProcApmStatus( ac, bs, bf, pc, sec );
    if ( !usedApm ) {
 #ifdef QT_QWS_IPAQ_NO_APM
        int fd;
        int err;
        struct bat_dev batt_info;
        memset(&batt_info, 0, sizeof(batt_info));
        fd = ::open("/dev/ts",O_RDONLY);
        if( fd < 0 )
            return;
        ioctl(fd, GET_BATTERY_STATUS, &batt_info);
        ac_status = batt_info.ac_status;
        ps->percentRemain = ( 425 * batt_info.batt1_voltage ) / 1000 - 298; // from h3600_ts.c
        ps->secsRemain = -1; // seconds is bogus on iPAQ
        ::close (fd);
 #else
        ps->percentRemain = 100;
        ps->secsRemain = -1;
        ps->percentAccurate = FALSE;
 #endif
    }
 }
diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index 95c4a1b..7463074 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -1488,319 +1488,319 @@ void QPEApplication::shutdown()
 /*!
  \internal
 */
 void QPEApplication::restart()
 {
        // Implement in server's QPEApplication subclass
 }
 static QPtrDict<void>* stylusDict = 0;
 static void createDict()
 {
        if ( !stylusDict )
                stylusDict = new QPtrDict<void>;
 }
 /*!
  Returns the current StylusMode for widget \a w.
  \sa setStylusOperation() StylusMode
 */
 QPEApplication::StylusMode QPEApplication::stylusOperation( QWidget* w )
 {
        if ( stylusDict )
                return ( StylusMode ) ( int ) stylusDict->find( w );
        return LeftOnly;
 }
 /*!
    \enum QPEApplication::StylusMode
    \value LeftOnly the stylus only generates LeftButton
                       events (the default).
    \value RightOnHold the stylus generates RightButton events
                       if the user uses the press-and-hold gesture.
    \sa setStylusOperation() stylusOperation()
 */
 /*!
  Causes widget \a w to receive mouse events according to the stylus
  \a mode.
  \sa stylusOperation() StylusMode
 */
 void QPEApplication::setStylusOperation( QWidget * w, StylusMode mode )
 {
        createDict();
        if ( mode == LeftOnly ) {
                stylusDict->remove
                ( w );
                w->removeEventFilter( qApp );
        }
        else {
                stylusDict->insert( w, ( void* ) mode );
                connect( w, SIGNAL( destroyed() ), qApp, SLOT( removeSenderFromStylusDict() ) );
                w->installEventFilter( qApp );
        }
 }
 /*!
  \reimp
 */
 bool QPEApplication::eventFilter( QObject *o, QEvent *e )
 {
        if ( stylusDict && e->type() >= QEvent::MouseButtonPress && e->type() <= QEvent::MouseMove ) {
                QMouseEvent * me = ( QMouseEvent* ) e;
                StylusMode mode = (StylusMode)(int)stylusDict->find(o);
                switch (mode) {
                        case RightOnHold:
                                switch ( me->type() ) {
                                        case QEvent::MouseButtonPress:
                                                if ( me->button() == LeftButton ) {
                                                        d->presstimer = startTimer(500); // #### pref.
                                                        d->presswidget = (QWidget*)o;
                                                        d->presspos = me->pos();
                                                        d->rightpressed = FALSE;
                                                }
                                                break;
                                        case QEvent::MouseMove:
                                                if (d->presstimer && (me->pos() - d->presspos).manhattanLength() > 8) {
                                                        killTimer(d->presstimer);
                                                        d->presstimer = 0;
                                                }
                                                break;
                                        case QEvent::MouseButtonRelease:
                                                if ( me->button() == LeftButton ) {
                                                        if ( d->presstimer ) {
                                                                killTimer(d->presstimer);
                                                                d->presstimer = 0;
                                                        }
                                                        if ( d->rightpressed && d->presswidget ) {
                                                                // Right released
                                                                postEvent( d->presswidget,
                                                                           new QMouseEvent( QEvent::MouseButtonRelease, me->pos(),
                                                                                            RightButton, LeftButton + RightButton ) );
                                                                // Left released, off-widget
                                                                postEvent( d->presswidget,
                                                                           new QMouseEvent( QEvent::MouseMove, QPoint( -1, -1),
                                                                                            LeftButton, LeftButton ) );
                                                                postEvent( d->presswidget,
                                                                           new QMouseEvent( QEvent::MouseButtonRelease, QPoint( -1, -1),
                                                                                            LeftButton, LeftButton ) );
                                                                d->rightpressed = FALSE;
                                                                return TRUE; // don't send the real Left release
                                                        }
                                                }
                                                break;
                                        default:
                                                break;
                                }
                                break;
                        default:
                                ;
                }
        }
        else if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
                QKeyEvent *ke = (QKeyEvent *)e;
                if ( ke->key() == Key_Enter ) {
                        if ( o->isA( "QRadioButton" ) || o->isA( "QCheckBox" ) ) {
                                postEvent( o, new QKeyEvent( e->type(), Key_Space, ' ',
                                                             ke->state(), " ", ke->isAutoRepeat(), ke->count() ) );
                                return TRUE;
                        }
                }
        }
        return FALSE;
 }
 /*!
  \reimp
 */
 void QPEApplication::timerEvent( QTimerEvent *e )
 {
        if ( e->timerId() == d->presstimer && d->presswidget ) {
                // Right pressed
                postEvent( d->presswidget,
                           new QMouseEvent( QEvent::MouseButtonPress, d->presspos,
                                            RightButton, LeftButton ) );
                killTimer( d->presstimer );
                d->presstimer = 0;
                d->rightpressed = TRUE;
        }
 }
 void QPEApplication::removeSenderFromStylusDict()
 {
        stylusDict->remove
        ( ( void* ) sender() );
        if ( d->presswidget == sender() )
                d->presswidget = 0;
 }
 /*!
  \internal
 */
 bool QPEApplication::keyboardGrabbed() const
 {
        return d->kbgrabbed;
 }
 /*!
  Reverses the effect of grabKeyboard(). This is called automatically
  on program exit.
 */
 void QPEApplication::ungrabKeyboard()
 {
        ((QPEApplication *) qApp )-> d-> kbgrabbed = false;
 }
 /*!
  Grabs the physical keyboard keys, e.g. the application's launching
  keys. Instead of launching applications when these keys are pressed
  the signals emitted are sent to this application instead. Some games
  programs take over the launch keys in this way to make interaction
  easier.
  \sa ungrabKeyboard()
 */
 void QPEApplication::grabKeyboard()
 {
        ((QPEApplication *) qApp )-> d-> kbgrabbed = true;
 }
 /*!
  \reimp
 */
 int QPEApplication::exec()
 {
 #ifndef QT_NO_COP
        d->sendQCopQ();
 #endif
        if ( d->keep_running )
                //|| d->qpe_main_widget && d->qpe_main_widget->isVisible() )
                return QApplication::exec();
 #ifndef QT_NO_COP
        {
                QCopEnvelope e( "QPE/System", "closing(QString)" );
                e << d->appName;
        }
 #endif
        processEvents();
        return 0;
 }
 /*!
  \internal
  External request for application to quit.  Quits if possible without
  loosing state.
 */
 void QPEApplication::tryQuit()
 {
        if ( activeModalWidget() || strcmp( argv() [ 0 ], "embeddedkonsole" ) == 0 )
                return ; // Inside modal loop or konsole. Too hard to save state.
 #ifndef QT_NO_COP
        {
                QCopEnvelope e( "QPE/System", "closing(QString)" );
                e << d->appName;
        }
 #endif
        processEvents();
        quit();
 }
 /*!
  \internal
  User initiated quit.  Makes the window 'Go Away'.  If preloaded this means
  hiding the window.  If not it means quitting the application.
  As this is user initiated we don't need to check state.
 */
 void QPEApplication::hideOrQuit()
 {
        processEvents();
        // If we are a preloaded application we don't actually quit, so emit
        // a System message indicating we're quasi-closing.
        if ( d->preloaded && d->qpe_main_widget )
 #ifndef QT_NO_COP
        {
                QCopEnvelope e("QPE/System", "fastAppHiding(QString)" );
                e << d->appName;
                d->qpe_main_widget->hide();
        }
 #endif
        else
                quit();
 }
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SHARP)
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
 // The libraries with the skiff package (and possibly others) have
 // completely useless implementations of builtin new and delete that
 // use about 50% of your CPU. Here we revert to the simple libc
 // functions.
 void* operator new[]( size_t size )
 {
        return malloc( size );
 }
 void* operator new( size_t size )
 {
        return malloc( size );
 }
 void operator delete[]( void* p )
 {
        free( p );
 }
 void operator delete[]( void* p, size_t /*size*/ )
 {
        free( p );
 }
 void operator delete( void* p )
 {
        free( p );
 }
 void operator delete( void* p, size_t /*size*/ )
 {
        free( p );
 }
 #endif
 #if ( QT_VERSION <= 230 ) && !defined(SINGLE_APP)
 #include <qwidgetlist.h>
 #ifdef QWS
 #include <qgfx_qws.h>
 extern QRect qt_maxWindowRect;
 void qt_setMaxWindowRect(const QRect& r )
 {
        qt_maxWindowRect = qt_screen->mapFromDevice( r,
                           qt_screen->mapToDevice( QSize( qt_screen->width(), qt_screen->height() ) ) );
        // Re-resize any maximized windows
        QWidgetList* l = QApplication::topLevelWidgets();
        if ( l ) {
                QWidget * w = l->first();
                while ( w ) {
                        if ( w->isVisible() && w->isMaximized() ) {
                                w->showMaximized();
                        }
                        w = l->next();
                }
                delete l;
        }
 }
 #endif
 #endif
diff --git a/library/storage.cpp b/library/storage.cpp
index 3668d29..a7c466d 100644
--- a/library/storage.cpp
+++ b/library/storage.cpp
@@ -1,200 +1,200 @@
 /**********************************************************************
 ** Copyright (C) Holger 'zecke' Freyther <freyther@kde.org>
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <qpe/storage.h>
-#ifdef QT_QWS_SHARP
+#ifdef QT_QWS_SL5XXX
 #include <qpe/custom.h>
 #endif
 #include <qfile.h>
 #include <qtimer.h>
 #include <qcopchannel_qws.h>
 #include <stdio.h>
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
 #include <sys/vfs.h>
 #include <mntent.h>
 #endif
 #include <qstringlist.h>
 static bool isCF(const QString& m)
 {
    FILE* f = fopen("/var/run/stab", "r");
    if (!f) f = fopen("/var/state/pcmcia/stab", "r");
    if (!f) f = fopen("/var/lib/pcmcia/stab", "r");
    if ( f ) {
        char line[1024];
        char devtype[80];
        char devname[80];
        while ( fgets( line, 1024, f ) ) {
              // 0       ide     ide-cs  0       hda     3       0
            if ( sscanf(line,"%*d %s %*s %*s %s", devtype, devname )==2 )
              {
                  if ( QString(devtype) == "ide" && m.find(devname)>0 ) {
                      fclose(f);
                      return TRUE;
                  }
              }
        }
        fclose(f);
    }
    return FALSE;
 }
 StorageInfo::StorageInfo( QObject *parent )
    : QObject( parent )
 {
    mFileSystems.setAutoDelete( TRUE );
    channel = new QCopChannel( "QPE/Card", this );
    connect( channel, SIGNAL(received(const QCString &, const QByteArray &)),
       this, SLOT(cardMessage( const QCString &, const QByteArray &)) );
    update();
 }
 const FileSystem *StorageInfo::fileSystemOf( const QString &filename )
 {
    for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i) {
  if ( filename.startsWith( (*i)->path() ) )
       return (*i);
    }
    return 0;
 }
 void StorageInfo::cardMessage( const QCString& msg, const QByteArray& )
 {
    if ( msg == "mtabChanged()" )
        update();
 }
 // cause of the lack of a d pointer we need
 // to store informations in a config file :(
 void StorageInfo::update()
 {
    //qDebug("StorageInfo::updating");
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
    struct mntent *me;
    FILE *mntfp = setmntent( "/etc/mtab", "r" );
    QStringList curdisks;
    QStringList curopts;
    QStringList curfs;
    bool rebuild = FALSE;
    int n=0;
    if ( mntfp ) {
  while ( (me = getmntent( mntfp )) != 0 ) {
      QString fs = me->mnt_fsname;
      if ( fs.left(7)=="/dev/hd" || fs.left(7)=="/dev/sd"
           || fs.left(8)=="/dev/mtd" || fs.left(9) == "/dev/mmcd"
           || fs.left( 14 ) == "/dev/mmc/part1"
           || fs.left(5)=="tmpfs" )
      {
    n++;
    curdisks.append(fs);
    curopts.append( me->mnt_opts );
    //qDebug("-->fs %s opts %s", fs.latin1(), me->mnt_opts );
    curfs.append( me->mnt_dir );
    bool found = FALSE;
    for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i) {
        if ( (*i)->disk() == fs ) {
      found = TRUE;
      break;
        }
    }
    if ( !found )
        rebuild = TRUE;
      }
  }
  endmntent( mntfp );
    }
    if ( rebuild || n != (int)mFileSystems.count() ) {
  mFileSystems.clear();
  QStringList::ConstIterator it=curdisks.begin();
  QStringList::ConstIterator fsit=curfs.begin();
  QStringList::ConstIterator optsIt=curopts.begin();
  for (; it!=curdisks.end(); ++it, ++fsit, ++optsIt) {
      QString opts = *optsIt;
      QString disk = *it;
      QString humanname;
      bool removable = FALSE;
      if ( isCF(disk) ) {
    humanname = tr("CF Card");
    removable = TRUE;
      } else if ( disk == "/dev/hda1" ) {
    humanname = tr("Hard Disk");
      } else if ( disk.left(9) == "/dev/mmcd" ) {
    humanname = tr("SD Card");
    removable = TRUE;
      } else if ( disk.left( 14 ) == "/dev/mmc/part1" ) {
    humanname = tr("MMC Card");
    removable = TRUE;
      } else if ( disk.left(7) == "/dev/hd" )
    humanname = tr("Hard Disk") + " " + disk;
      else if ( disk.left(7) == "/dev/sd" )
    humanname = tr("SCSI Hard Disk") + " " + disk;
      else if ( disk.left(14) == "/dev/mtdblock6" ) //openzaurus ramfs
    humanname = tr("Internal Memory");
      else if ( disk == "/dev/mtdblock1" || humanname == "/dev/mtdblock/1" )
    humanname = tr("Internal Storage");
      else if ( disk.left(14) == "/dev/mtdblock/" )
    humanname = tr("Internal Storage") + " " + disk;
      else if ( disk.left(13) == "/dev/mtdblock" )
    humanname = tr("Internal Storage") + " " + disk;
      else if ( disk.left(5) == "tmpfs" ) //ipaqs /mnt/ramfs
    humanname = tr("Internal Memory");
      FileSystem *fs = new FileSystem( disk, *fsit, humanname, removable, opts );
      mFileSystems.append( fs );
  }
  emit disksChanged();
    } else {
  // just update them
  for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
      i.current()->update();
    }
 #endif
 }
 //---------------------------------------------------------------------------
 FileSystem::FileSystem( const QString &disk, const QString &path, const QString &name, bool rem, const QString &o )
    : fsdisk( disk ), fspath( path ), humanname( name ), blkSize(512), totalBlks(0), availBlks(0), removable( rem ), opts( o )
 {
    update();
 }
 void FileSystem::update()
 {
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
    struct statfs fs;
    if ( !statfs( fspath.latin1(), &fs ) ) {
  blkSize = fs.f_bsize;
  totalBlks = fs.f_blocks;
  availBlks = fs.f_bavail;
    } else {
  blkSize = 0;
  totalBlks = 0;
  availBlks = 0;
    }
 #endif
 }
diff --git a/mkspecs/qws/linux-sharp-g++/qmake.conf b/mkspecs/qws/linux-sharp-g++/qmake.conf
index 06bf445..814b4fc 100644
--- a/mkspecs/qws/linux-sharp-g++/qmake.conf
+++ b/mkspecs/qws/linux-sharp-g++/qmake.conf
@@ -1,76 +1,76 @@
 #
 # $Id$
 #
 # qmake configuration for linux-g++ using the arm-linux-g++ crosscompiler
 #
        MAKEFILE_GENERATOR= UNIX
        TEMPLATE        = app
        CONFIG          += qt warn_on release
        QMAKE_CC        = arm-linux-gcc
        QMAKE_LEX       = flex
        QMAKE_LEXFLAGS  =
        QMAKE_YACC      = yacc
        QMAKE_YACCFLAGS         = -d
        QMAKE_CFLAGS    = -pipe $(CFLAGS_EXTRA)
        QMAKE_CFLAGS_WARN_ON= -Wall -W
        QMAKE_CFLAGS_WARN_OFF=
        QMAKE_CFLAGS_RELEASE= $(if $(CFLAGS_RELEASE),$(CFLAGS_RELEASE), -O2)
        QMAKE_CFLAGS_DEBUG= -g
        QMAKE_CFLAGS_SHLIB= -fPIC
        QMAKE_CFLAGS_YACC= -Wno-unused -Wno-parentheses
        QMAKE_CFLAGS_THREAD= -D_REENTRANT
-        QMAKE_CXX       = arm-linux-g++ -DQT_QWS_SHARP -DQT_QWS_EBX
+        QMAKE_CXX       = arm-linux-g++ -DQT_QWS_SL5XXX -DQT_QWS_SHARP -DQT_QWS_EBX -DQT_QWS_CUSTOM
        QMAKE_CXXFLAGS  = $$QMAKE_CFLAGS  -DQWS -fno-exceptions -fno-rtti $(CXXFLAGS_EXTRA)
        QMAKE_CXXFLAGS_WARN_ON= $$QMAKE_CFLAGS_WARN_ON
        QMAKE_CXXFLAGS_WARN_OFF= $$QMAKE_CFLAGS_WARN_OFF
        QMAKE_CXXFLAGS_RELEASE= $$QMAKE_CFLAGS_RELEASE
        QMAKE_CXXFLAGS_DEBUG= $$QMAKE_CFLAGS_DEBUG
        QMAKE_CXXFLAGS_SHLIB= $$QMAKE_CFLAGS_SHLIB
        QMAKE_CXXFLAGS_YACC= $$QMAKE_CFLAGS_YACC
        QMAKE_CXXFLAGS_THREAD= $$QMAKE_CFLAGS_THREAD
        QMAKE_INCDIR    =
        QMAKE_LIBDIR    =
        QMAKE_INCDIR_X11= 
        QMAKE_LIBDIR_X11= 
        QMAKE_INCDIR_QT         = $(QTDIR)/include
        QMAKE_LIBDIR_QT         = $(QTDIR)/lib
        QMAKE_INCDIR_OPENGL= /usr/X11R6/include
        QMAKE_LIBDIR_OPENGL= /usr/X11R6/lib
        QMAKE_LINK      = arm-linux-gcc
        QMAKE_LINK_SHLIB= arm-linux-gcc
        QMAKE_LFLAGS    = $(LFLAGS_EXTRA)
        QMAKE_LFLAGS_RELEASE=
        QMAKE_LFLAGS_DEBUG=
 QMAKE_LFLAGS_SHLIB      = -shared
 QMAKE_LFLAGS_PLUGIN     = $$QMAKE_LFLAGS_SHLIB
 QMAKE_LFLAGS_SONAME     = -Wl,-soname,
 QMAKE_LFLAGS_THREAD     =
 QMAKE_RPATH             = -Wl,-rpath,
        QMAKE_LIBS      = $(LIBS_EXTRA)
 QMAKE_LIBS_DYNLOAD      = -ldl
        QMAKE_LIBS_X11  = 
        QMAKE_LIBS_X11SM= 
        QMAKE_LIBS_QT   = -lqte
 QMAKE_LIBS_QT_THREAD    = -lqte-mt
        QMAKE_LIBS_QT_OPENGL= -lqgl
 QMAKE_LIBS_THREAD       = -lpthread
        QMAKE_MOC       = $(QTDIR)/bin/moc
        QMAKE_UIC       = $(QTDIR)/bin/uic
        QMAKE_AR        = ar cqs
        QMAKE_RANLIB    =
        QMAKE_TAR       = tar -cf
        QMAKE_GZIP      = gzip -9f
        QMAKE_COPY      = cp -f
        QMAKE_MOVE      = mv -f
        QMAKE_DEL_FILE  = rm -f
        QMAKE_DEL_DIR   = rmdir
diff --git a/noncore/multimedia/opieplayer2/mediaplayer.cpp b/noncore/multimedia/opieplayer2/mediaplayer.cpp
index 0ec6fad..d4396d2 100644
--- a/noncore/multimedia/opieplayer2/mediaplayer.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayer.cpp
@@ -40,375 +40,375 @@ MediaPlayer::MediaPlayer( PlayListWidget &_playList, MediaPlayerState &_mediaPla
    fd=-1;fl=-1;
    playList.setCaption( tr( "OpiePlayer: Initializating" ) );
    qApp->processEvents();
    //    QPEApplication::grabKeyboard(); // EVIL
    connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
    connect( &mediaPlayerState, SIGNAL( playingToggled( bool ) ), this, SLOT( setPlaying( bool ) ) );
 // What is pauseCheck good for? (Simon)
 //    connect( &mediaPlayerState, SIGNAL( pausedToggled( bool ) ),  this, SLOT( pauseCheck( bool ) ) );
    connect( &mediaPlayerState, SIGNAL( next() ), this, SLOT( next() ) );
    connect( &mediaPlayerState, SIGNAL( prev() ), this, SLOT( prev() ) );
    connect( &mediaPlayerState, SIGNAL( blankToggled( bool ) ), this, SLOT ( blank( bool ) ) );
    volControl = new VolumeControl;
    Config cfg( "OpiePlayer" );
    cfg.setGroup("PlayList");
    QString currentPlaylist = cfg.readEntry( "CurrentPlaylist", "default");
    playList.setCaption( tr( "OpiePlayer: " ) + QFileInfo(currentPlaylist).baseName() );
    m_skinLoader = new SkinLoader;
    m_skinLoader->schedule( AudioWidget::guiInfo() );
    m_skinLoader->schedule( VideoWidget::guiInfo() );
    m_skinLoader->start();
 }
 MediaPlayer::~MediaPlayer() {
    // this shold never happen, but one never knows...
    if ( xine ) {
        xine->ensureInitialized();
        delete xine;
    }
    delete m_xineControl;
    delete m_audioUI;
    delete m_videoUI;
    delete volControl;
 }
 void MediaPlayer::pauseCheck( bool b ) {
     if ( b && !mediaPlayerState.isPlaying() ) {
         mediaPlayerState.setPaused( FALSE );
     }
 }
 void MediaPlayer::play() {
    mediaPlayerState.setPlaying( FALSE );
    mediaPlayerState.setPlaying( TRUE );
 }
 void MediaPlayer::setPlaying( bool play ) {
    if ( !play ) {
        return;
    }
    if ( mediaPlayerState.isPaused() ) {
        mediaPlayerState.setPaused( FALSE );
        return;
    }
    QString tickerText, time, fileName;
    if ( playList.currentTab() != PlayListWidget::CurrentPlayList ) {
        //if playing in file list.. play in a different way
        // random and looping settings enabled causes problems here,
        // since there is no selected file in the playlist, but a selected file in the file list,
        // so we remember and shutoff
        l = mediaPlayerState.isLooping();
        if(l) {
            mediaPlayerState.setLooping( false );
        }
        r = mediaPlayerState.isShuffled();
        mediaPlayerState.setShuffled( false );
    }
    PlayListWidget::Entry playListEntry = playList.currentEntry();
    fileName = playListEntry.name;
    xineControl()->play( playListEntry.file );
    long seconds = mediaPlayerState.length();
    time.sprintf("%li:%02i", seconds/60, (int)seconds%60 );
    if( fileName.left(4) == "http" ) {
        fileName = QFileInfo( fileName ).baseName();
       if ( xineControl()->getMetaInfo().isEmpty() ) {
           tickerText = tr( " File: " ) + fileName;
       } else {
           tickerText = xineControl()->getMetaInfo();
       }
    } else {
        if ( xineControl()->getMetaInfo().isEmpty() ) {
            tickerText = tr( " File: " ) + fileName + tr( ", Length: " ) + time + "  ";
        } else {
            tickerText = xineControl()->getMetaInfo() + " Length: " + time + "  ";
        }
    }
    audioUI()->setTickerText( tickerText );
 }
 void MediaPlayer::prev() {
    if( playList.currentTab() == PlayListWidget::CurrentPlayList ) { //if using the playlist
        if ( playList.prev() ) {
            play();
        } else if ( mediaPlayerState.isLooping() ) {
            if ( playList.last() ) {
                play();
            }
        } else {
            mediaPlayerState.setList();
        }
    }
 }
 void MediaPlayer::next() {
    if(playList.currentTab() == PlayListWidget::CurrentPlayList) { //if using the playlist
        if ( playList.next() ) {
            play();
        } else if ( mediaPlayerState.isLooping() ) {
            if ( playList.first() ) {
                play();
            }
        } else {
            mediaPlayerState.setList();
        }
    } else { //if playing from file list, let's just stop
        qDebug("<<<<<<<<<<<<<<<<<stop for filelists");
        mediaPlayerState.setPlaying(false);
        mediaPlayerState.setDisplayType( MediaPlayerState::MediaSelection );
        if(l) mediaPlayerState.setLooping(l);
        if(r) mediaPlayerState.setShuffled(r);
    }
    qApp->processEvents();
 }
 void MediaPlayer::startDecreasingVolume() {
    volumeDirection = -1;
    startTimer( 100 );
    volControl->decVol(2);
 }
 void MediaPlayer::startIncreasingVolume() {
    volumeDirection = +1;
    startTimer( 100 );
    volControl->incVol(2);
 }
 bool drawnOnScreenDisplay = FALSE;
 unsigned int onScreenDisplayVolume = 0;
 const int yoff = 110;
 void MediaPlayer::stopChangingVolume() {
    killTimers();
    // Get rid of the on-screen display stuff
    drawnOnScreenDisplay = FALSE;
    onScreenDisplayVolume = 0;
    int w=0;
    int h=0;
    if( !xineControl()->hasVideo() ) {
        w = audioUI()->width();
        h = audioUI()->height();
        audioUI()->repaint( ( w - 200 ) / 2, h - yoff, 200 + 9, 70, FALSE );
    } else {
        w = videoUI()->width();
        h = videoUI()->height();
        videoUI()->repaint( ( w - 200 ) / 2, h - yoff, 200 + 9, 70, FALSE );
    }
 }
 void MediaPlayer::timerEvent( QTimerEvent * ) {
    if ( volumeDirection == +1 ) {
        volControl->incVol( 2 );
    } else if ( volumeDirection == -1 ) {
        volControl->decVol( 2 );
    }
      // TODO FIXME
      // huh??
    unsigned int v= 0;
    v = volControl->volume();
    v = v / 10;
    if ( drawnOnScreenDisplay && onScreenDisplayVolume == v ) {
        return;
    }
    int w=0; int h=0;
    if( !xineControl()->hasVideo() ) {
        w = audioUI()->width();
        h = audioUI()->height();
        if ( drawnOnScreenDisplay ) {
            if ( onScreenDisplayVolume > v ) {
                audioUI()->repaint( ( w - 200 ) / 2 + v * 20 + 0, h - yoff + 40, ( onScreenDisplayVolume - v ) * 20 + 9, 30, FALSE );
            }
        }
        drawnOnScreenDisplay = TRUE;
        onScreenDisplayVolume = v;
        QPainter p( audioUI() );
        p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
        p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
        QFont f;
        f.setPixelSize( 20 );
        f.setBold( TRUE );
        p.setFont( f );
        p.drawText( (w - 200) / 2, h - yoff + 20, tr("Volume") );
        for ( unsigned int i = 0; i < 10; i++ ) {
            if ( v > i ) {
                p.drawRect( ( w - 200 ) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
            } else {
                p.drawRect( ( w - 200 ) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
            }
        }
    } else {
        w = videoUI()->width();
        h = videoUI()->height();
        if ( drawnOnScreenDisplay ) {
            if ( onScreenDisplayVolume > v ) {
                videoUI()->repaint( (w - 200) / 2 + v * 20 + 0, h - yoff + 40, ( onScreenDisplayVolume - v ) * 20 + 9, 30, FALSE );
            }
        }
        drawnOnScreenDisplay = TRUE;
        onScreenDisplayVolume = v;
        QPainter p( videoUI() );
        p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
        p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
        QFont f;
        f.setPixelSize( 20 );
        f.setBold( TRUE );
        p.setFont( f );
        p.drawText( (w - 200) / 2, h - yoff + 20, tr( "Volume" ) );
        for ( unsigned int i = 0; i < 10; i++ ) {
            if ( v > i ) {
                p.drawRect( (w - 200) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
            } else {
                p.drawRect( (w - 200) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
            }
        }
    }
 }
 void MediaPlayer::blank( bool b ) {
    fd=open("/dev/fb0",O_RDWR);
-#ifdef QT_QWS_EBX
+#ifdef QT_QWS_SL5XXX
    fl= open( "/dev/fl", O_RDWR );
 #endif
    if (fd != -1) {
        if ( b ) {
            qDebug("do blanking");
-#ifdef QT_QWS_EBX
+#ifdef QT_QWS_SL5XXX
            ioctl( fd, FBIOBLANK, 1 );
            if(fl !=-1) {
                ioctl( fl, 2 );
                ::close(fl);
            }
 #else
            ioctl( fd, FBIOBLANK, 3 );
 #endif
            isBlanked = TRUE;
        } else {
            qDebug("do unblanking");
            ioctl( fd, FBIOBLANK, 0);
-#ifdef QT_QWS_EBX
+#ifdef QT_QWS_SL5XXX
            if(fl != -1) {
                ioctl( fl, 1);
                ::close(fl);
            }
 #endif
            isBlanked = FALSE;
        }
        close( fd );
    } else {
        qDebug("<< /dev/fb0 could not be opened  >>");
    }
 }
 void MediaPlayer::keyReleaseEvent( QKeyEvent *e) {
    switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
      case Key_Home:
          break;
      case Key_F9: //activity
          break;
      case Key_F10: //contacts
          break;
      case Key_F11: //menu
          break;
      case Key_F12: //home
          qDebug("Blank here");
 //          mediaPlayerState->toggleBlank();
          break;
      case Key_F13: //mail
          qDebug("Blank here");
          //  mediaPlayerState->toggleBlank();
          break;
    }
 }
 void MediaPlayer::cleanUp() {// this happens on closing
     Config cfg( "OpiePlayer" );
     mediaPlayerState.writeConfig( cfg );
     playList.writeDefaultPlaylist( );
 //     QPEApplication::grabKeyboard();
 //     QPEApplication::ungrabKeyboard();
 }
 void MediaPlayer::recreateAudioAndVideoWidgets() const
 {
    delete m_skinLoader;
    delete m_xineControl;
    delete m_audioUI;
    delete m_videoUI;
    m_audioUI = new AudioWidget( playList, mediaPlayerState, 0, "audioUI" );
    m_videoUI = new VideoWidget( playList, mediaPlayerState, 0, "videoUI" );
    connect( m_audioUI,  SIGNAL( moreClicked() ), this, SLOT( startIncreasingVolume() ) );
    connect( m_audioUI,  SIGNAL( lessClicked() ),  this, SLOT( startDecreasingVolume() ) );
    connect( m_audioUI,  SIGNAL( moreReleased() ), this, SLOT( stopChangingVolume() ) );
    connect( m_audioUI,  SIGNAL( lessReleased() ), this, SLOT( stopChangingVolume() ) );
    connect( m_videoUI,  SIGNAL( moreClicked() ), this, SLOT( startIncreasingVolume() ) );
    connect( m_videoUI,  SIGNAL( lessClicked() ),  this, SLOT( startDecreasingVolume() ) );
    connect( m_videoUI,  SIGNAL( moreReleased() ), this, SLOT( stopChangingVolume() ) );
    connect( m_videoUI,  SIGNAL( lessReleased() ), this, SLOT( stopChangingVolume() ) );
    if ( !xine )
        xine = new XINE::Lib( XINE::Lib::InitializeImmediately );
    m_xineControl = new XineControl( xine, m_videoUI->vidWidget(), mediaPlayerState );
    xine = 0;
 }
 AudioWidget *MediaPlayer::audioUI() const
 {
    if ( !m_audioUI )
        recreateAudioAndVideoWidgets();
    return m_audioUI;
 }
 VideoWidget *MediaPlayer::videoUI() const
 {
    if ( !m_videoUI )
        recreateAudioAndVideoWidgets();
    return m_videoUI;
 }
 XineControl *MediaPlayer::xineControl() const
 {
    if ( !m_xineControl )
        recreateAudioAndVideoWidgets();
    return m_xineControl;
 }
 void MediaPlayer::reloadSkins()
 {
    audioUI()->loadSkin();
    videoUI()->loadSkin();
 }
diff --git a/noncore/settings/sound/soundsettings.cpp b/noncore/settings/sound/soundsettings.cpp
index dd341c0..afcdd49 100644
--- a/noncore/settings/sound/soundsettings.cpp
+++ b/noncore/settings/sound/soundsettings.cpp
@@ -1,211 +1,211 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 // parts copyright 2002 L.J. Potter
 #include "soundsettings.h"
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/storage.h>
 #include <qmessagebox.h>
 #include <qapplication.h>
 #include <qslider.h>
 #include <qcheckbox.h>
 #include <qlineedit.h>
 #include <qcombobox.h>
 #include <qlabel.h>
 #include <sys/utsname.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/stat.h>
 SoundSettings::SoundSettings( QWidget* parent,  const char* objname, WFlags fl )
        : SoundSettingsBase( parent, objname, TRUE, fl )
 {
    keyReset=FALSE;
    noWarning=false;
    Config config( "qpe");
    config.setGroup( "Volume" );
    Config cfg("Vmemo");
    connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
    AlertCheckBox->setChecked(cfg.readBoolEntry("Alert"));
    
    cfg.setGroup("Record");
    int rate=config.readNumEntry("SampleRate", 22050);
    if(rate == 8000)
        sampleRate->setCurrentItem(0);
    else if(rate == 11025)
        sampleRate->setCurrentItem(1);
    else if(rate == 22050)
        sampleRate->setCurrentItem(2);
    else if(rate == 33075)
        sampleRate->setCurrentItem(3);
    else if(rate==44100)
        sampleRate->setCurrentItem(4);
    stereoCheckBox->setChecked(cfg.readNumEntry("Stereo", 0));
 //TODO hide if zaurus- mono only
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
 //since ipaq and zaurus have particular
 //devices
    bool systemZaurus=FALSE;
    struct utsname name; /* check for embedix kernel running on the zaurus*/
    if (uname(&name) != -1) {// TODO change this here,...
        QString release=name.release;
        if( release.find("embedix",0,TRUE) != -1) {
            qDebug("IS System Zaurus");
            systemZaurus=TRUE;
        }
    }
    if(!systemZaurus) {
        stereoCheckBox->setChecked(TRUE);
    }
    stereoCheckBox->setEnabled(FALSE);
    sixteenBitCheckBox->setEnabled(FALSE);
 #else
 #endif
    int sRate=cfg.readNumEntry("SizeLimit", 30);
    qDebug("%d",sRate);
    if(sRate ==30)
        timeLimitComboBox->setCurrentItem(0);
    else if(sRate==20)
        timeLimitComboBox->setCurrentItem(1);
    else if(sRate == 15)
        timeLimitComboBox->setCurrentItem(2);
    else if(sRate == 10)
        timeLimitComboBox->setCurrentItem(3);
    else if(sRate == 5)
        timeLimitComboBox->setCurrentItem(4);
    else 
        timeLimitComboBox->setCurrentItem(5);
    sixteenBitCheckBox->setChecked(cfg.readNumEntry("SixteenBit", 1));
    cfg.setGroup("Defaults");
    keyComboBox->setCurrentItem(cfg.readNumEntry("toggleKey") );
    updateStorageCombo();
    connect( LocationComboBox,SIGNAL(activated(const QString &)), this,
             SLOT( setLocation(const QString &)));
    connect( keyComboBox,SIGNAL(activated( int)), this,
             SLOT( setKeyButton( int)));
    connect( timeLimitComboBox,SIGNAL(activated( const QString &)), this,
             SLOT( setSizeLimitButton(const QString &)));
    connect( restartCheckBox,SIGNAL( toggled( bool)), this,
             SLOT( restartOpie( bool)));
 //     connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
 }
 void SoundSettings::updateStorageCombo() {
    Config config( "Vmemo" );
    config.setGroup( "System" );
    QString loc = config.readEntry("RecLocation","/");
    int i=0;
    int set=0; 
    StorageInfo storageInfo;
    QString sName, sPath;
    QStringList list;
    list << "Documents : "+QPEApplication::documentDir();
    list << "tmp : /tmp";
    const QList<FileSystem> &fs = storageInfo.fileSystems();
    QListIterator<FileSystem> it ( fs );
    for( ; it.current(); ++it ){
        const QString name = (*it)->name();
        const QString path = (*it)->path();
        qDebug("storage name "+name +" storage path is "+path);
        list << name + ": " +path;
        if( loc.find( path,0,TRUE) != -1)
            set = i;      
 //   if(dit.current()->file().find(path) != -1 ) storage=name;
        i++;
    }
    LocationComboBox->insertStringList(list);
    qDebug("set item %d", set);
    LocationComboBox->setCurrentItem(set);
 }
 void SoundSettings::setLocation(const QString & string) {
    Config config( "Vmemo" );
    config.setGroup( "System" );
    config.writeEntry("RecLocation",string);
    qDebug("set location "+string);
    config.write();
 }
 void SoundSettings::cleanUp() {
    Config cfg("Vmemo");
    cfg.writeEntry("Alert",AlertCheckBox->isChecked());
    cfg.setGroup("Record");
    cfg.writeEntry("SampleRate",sampleRate->currentText());
    cfg.writeEntry("Stereo",stereoCheckBox->isChecked());
    cfg.writeEntry("SixteenBit",sixteenBitCheckBox->isChecked());
    if(keyReset && noWarning) {
        QCopEnvelope ("QPE/System", "restart()");
    }
 }
 void SoundSettings::setKeyButton( int index) {
    Config cfg("Vmemo");
    cfg.setGroup("Defaults");
    cfg.writeEntry( "toggleKey", index );
    keyReset = TRUE;
    if( index == 1) {
        cfg.writeEntry( "hideIcon", 0 );
        keyLabel->setText(tr("Shows icon"));
    }
    else {
        cfg.writeEntry( "hideIcon", 1);
        keyLabel->setText(tr("Hides icon"));
    }
    cfg.write();
 }
 void SoundSettings::updateLocationCombo() {
 }
 void SoundSettings::setSizeLimitButton(const QString &index) {
    Config cfg("Vmemo");
    cfg.setGroup("Record");
    if(index.find("Unlimited",0,TRUE) != -1)
        cfg.writeEntry("SizeLimit", -1);
    else
        cfg.writeEntry("SizeLimit", index);
    cfg.write();    
 }
 void SoundSettings::restartOpie(bool b) {
    noWarning=b;
 }
diff --git a/noncore/tools/formatter/formatter.cpp b/noncore/tools/formatter/formatter.cpp
index f275fbe..79a7f9e 100644
--- a/noncore/tools/formatter/formatter.cpp
+++ b/noncore/tools/formatter/formatter.cpp
@@ -1,575 +1,575 @@
 /****************************************************************************
 ** formatter.cpp
 **
 ** Copyright: Thu Apr 11 11:01:13 2002
 **      by:  L. J. Potter
 **
 ****************************************************************************/
 #include "formatter.h"
 #include "inputDialog.h"
 #include "output.h"
 #include <qpe/qpemenubar.h>
 #include <qpe/qpetoolbar.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #include <qpe/mimetype.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/storage.h>
 #include <qmultilineedit.h>
 #include <qstring.h>
 #include <qlist.h>
 #include <qstringlist.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qtstream.h>
 #include <qcombobox.h>
 #include <qpopupmenu.h>
 #include <qmessagebox.h>
 #include <qregexp.h>
 #include <qlabel.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qtabwidget.h>
 #include <qwidget.h>
 #include <qlayout.h>
 #include <qvariant.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/vfs.h>
 #include <mntent.h>
 #include <string.h>
 #include <errno.h>
 #define BLANK ' '
 #define DELIMITER '#'
 /* 
   Blah blah blah blah */
 FormatterApp::FormatterApp( QWidget* parent,  const char* name, bool modal, WFlags fl )
        : QMainWindow( parent, name, fl )
 //    : QDialog( parent, name, modal, fl )
 {
    if ( !name )
        setName( "FormatterApp" );
    connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
    setCaption( tr( "Formatter" ) );
    FormatterAppLayout = new QGridLayout( this ); 
    FormatterAppLayout->setSpacing( 2);
    FormatterAppLayout->setMargin( 2 );
    TabWidget = new QTabWidget( this, "TabWidget" );
    tab = new QWidget( TabWidget, "tab" );
    tabLayout = new QGridLayout( tab ); 
    tabLayout->setSpacing( 3);
    tabLayout->setMargin( 2);
    storageComboBox = new QComboBox( FALSE, tab, "storageComboBox" );
    storageComboBox->setMaximumWidth(220);
    tabLayout->addMultiCellWidget( storageComboBox, 0, 0, 0, 1);
    TextLabel4 = new QLabel( tab, "TextLabel4" );
    TextLabel4->setText( tr( "Storage Type" ) );
    tabLayout->addMultiCellWidget( TextLabel4, 1, 1, 0, 1);
    TextLabel2 = new QLabel( tab, "TextLabel2" );
    TextLabel2->setText( tr( "File Systems" ) );
    tabLayout->addMultiCellWidget( TextLabel2, 4, 4, 0, 1);
    fileSystemsCombo = new QComboBox( FALSE, tab, "fileSystemsCombo" );
    fileSystemsCombo->setMaximumWidth(220);
    tabLayout->addMultiCellWidget( fileSystemsCombo, 3, 3, 0, 1);
    QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Minimum );
    tabLayout->addItem( spacer, 2, 0 );
    formatPushButton = new QPushButton( tab, "formatPushButton" );
    formatPushButton->setText( tr( "Format" ) );
    formatPushButton->setMaximumWidth(170);
    
    tabLayout->addMultiCellWidget( formatPushButton, 6, 6, 0, 1);
    QSpacerItem* spacer_2 = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Minimum );
    tabLayout->addItem( spacer_2, 5, 0 );
    
    TabWidget->insertTab( tab, tr( "Main" ) );
    tab_2 = new QWidget( TabWidget, "tab_2" );
    tabLayout_2 = new QGridLayout( tab_2 ); 
    tabLayout_2->setSpacing(3);
    tabLayout_2->setMargin(2);
    mountPointLineEdit = new QLineEdit( tab_2, "mountPointLineEdit" );
    tabLayout_2->addMultiCellWidget( mountPointLineEdit, 0, 0, 0, 1);
    deviceComboBox = new QComboBox( FALSE, tab_2, "deviceComboBox" );
    tabLayout_2->addMultiCellWidget( deviceComboBox, 3, 3, 0, 1);
    TextLabel5 = new QLabel( tab_2, "TextLabel5" );
    TextLabel5->setText( tr( "CAUTION:\n"
                             "Changing parameters on this \n"
                             "page may cause your system \n"
                             "to stop functioning properly!!" ) );//idiot message
    tabLayout_2->addMultiCellWidget( TextLabel5, 6, 6, 0, 1);
    editPushButton = new QPushButton( tab_2, "editPushButton" );
    editPushButton->setText( tr( "Edit fstab" ) );
    editPushButton->setMaximumWidth(100);
    
    tabLayout_2->addMultiCellWidget( editPushButton, 7, 7, 0, 0 );
    fsckButton = new QPushButton( tab_2, "fsckPushButton" );
    fsckButton->setText( tr( "Check Disk" ) );
    fsckButton->setMaximumWidth(100);
    tabLayout_2->addMultiCellWidget( fsckButton, 7, 7, 1, 1);
    TextLabel3 = new QLabel( tab_2, "TextLabel3" );
    TextLabel3->setText( tr( "Device" ) );
    tabLayout_2->addMultiCellWidget( TextLabel3, 4, 4, 0, 1 );
    QSpacerItem* spacer_3 = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding );
    tabLayout_2->addItem( spacer_3, 5, 0 );
    TextLabel1 = new QLabel( tab_2, "TextLabel1" );
    TextLabel1->setText( tr( "Mount Point" ) );
    tabLayout_2->addMultiCellWidget( TextLabel1, 1, 1, 0, 1 );
    QSpacerItem* spacer_4 = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding );
    tabLayout_2->addItem( spacer_4, 2, 1 );
    TabWidget->insertTab( tab_2, tr( "Advanced" ) );
    FormatterAppLayout->addWidget( TabWidget, 0, 1 );
    connect( formatPushButton ,SIGNAL(released()),this,SLOT( doFormat()) );
    connect( editPushButton ,SIGNAL(released()),this,SLOT( editFstab()) );
    connect( fsckButton ,SIGNAL(released()),this,SLOT( doFsck()) );
    connect( fileSystemsCombo,SIGNAL(activated(int)),this,SLOT( fsComboSelected(int ) ));
    connect( storageComboBox,SIGNAL(activated(int)),this,SLOT( storageComboSelected(int ) ));
    connect( deviceComboBox,SIGNAL(activated(int)),this,SLOT( deviceComboSelected(int ) ));
    
    fillCombos();
 }
 FormatterApp::~FormatterApp() {
 }
 void FormatterApp::doFormat() {
    int err=0;
    Output *outDlg;
    QString umountS, remountS;
    QString text =  storageComboBox->currentText();
    QString currentText = storageComboBox->currentText();
    QString cmd;
    QString diskDevice = currentText.right( currentText.length() - currentText.find(" -> ",0,TRUE) - 4);
    QString diskName =  currentText.left(currentText.find(" -> ",0,TRUE));
    QString fs = fileSystemsCombo->currentText();
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX) // lets test on something cheap
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) // lets test on something cheap
 #else
    currentText  = diskDevice  = "/dev/fd0";
    umountS = "umount -v /floppy 2>&1";
    remountS = "mount -v /floppy 2>&1";
 #endif
    if( currentText.find("CF",0,TRUE) != -1) {
        umountS = "umount ";
        remountS = "mount ";
 //         umountS = "/sbin/cardctl eject";
 //         remountS = "/sbin/cardctl insert";
    }
    if( currentText.find("SD",0,TRUE) != -1) {
        umountS = "umount ";
        remountS = "mount ";
 //         umountS = "/etc/sdcontrol compeject";
 //         remountS = "/etc/sdcontrol insert";
    }
    switch ( QMessageBox::warning(this,tr("Format?!?"),tr("Really format\n") +diskName+" "+ currentText +
                                  tr("\nwith ") + fs + tr(" filesystem?!?\nYou will loose all data!!"),tr("Yes"),tr("No"),0,1,1) ) {
      case 0: {
          if(fs == "vfat")
              cmd = "mkdosfs -v " + diskDevice+" 2>&1";
          else if(fs == "ext2")
              cmd = "mke2fs -v " + diskDevice+" 2>&1";
          else {
              QMessageBox::warning(this, tr("Formatter"),tr("Could not format.\nUnknown type"), tr("Ok"));
              break;
          }
 //          cmd = "ls -l";
          outDlg = new Output(this, tr("Formatter Output"),FALSE);
          outDlg->showMaximized();
          outDlg->show();
          qApp->processEvents();
          FILE *fp;
          char line[130];
          outDlg->OutputEdit->append( tr("Trying to umount.") + currentText );
          outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
          sleep(1);
          qDebug("Command is "+umountS);
          fp = popen(  (const char *) umountS, "r");
          qDebug("%d", fp);
          if ( !fp ) {
              qDebug("Could not execute '" + umountS + "'! err=%d\n" +(QString)strerror(errno), err); 
              QMessageBox::warning( this, tr("Formatter"), tr("umount failed!"), tr("&OK") );
              pclose(fp);             
              return;
          } else {
 //               outDlg->OutputEdit->append( currentText + tr("\nhas been successfully umounted."));
 //             outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
              while ( fgets( line, sizeof line, fp)) {
                  if( ((QString)line).find("busy",0,TRUE) != -1) {
                      qDebug("Could not find '" + umountS); 
                      QMessageBox::warning( this, tr("Formatter"), tr("Could not umount.\nDevice is busy!"), tr("&OK") );
                      pclose(fp);             
                      return;
                  } else {
                      QString lineStr = line;
                      lineStr=lineStr.left(lineStr.length()-1);
                      outDlg->OutputEdit->append(lineStr);
                      outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
                  }
              }
          }
          pclose(fp);             
          qDebug("Command would be: "+cmd);
          outDlg->OutputEdit->append( tr("Trying to format.") );
          outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
          fp = popen(  (const char *) cmd, "r"); 
          while ( fgets( line, sizeof line, fp)) {
              if( ((QString)line).find("No such device",0,TRUE) != -1) {
                  qDebug("No such device '" + umountS); 
                  QMessageBox::warning( this, tr("Formatter"), tr("No such device!"), tr("&OK") );
                  pclose(fp);             
 //               outDlg->OutputEdit->append("No such device");
 //             outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
                  return;
              } else {
                  QString lineStr = line;
                  lineStr=lineStr.left(lineStr.length()-1);
                  outDlg->OutputEdit->append(lineStr);
                  outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
              }
          }
          outDlg->OutputEdit->append( currentText + tr("\nhas been successfully formatted."));
          outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
          pclose(fp);             
          outDlg->OutputEdit->append( tr("Trying to mount.") + currentText );
          outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
          fp = popen(  (const char *) remountS, "r"); 
          if ( !fp) {
              qDebug("Could not execute '" + remountS + "'! err=%d\n" +(QString)strerror(errno), err); 
              QMessageBox::warning( this, tr("Formatter"), tr("Card mount failed!"), tr("&OK") );
          } else {
              outDlg->OutputEdit->append( currentText + tr("\nhas been successfully mounted."));
              while ( fgets( line, sizeof line, fp)) {
                  QString lineStr = line;
                  lineStr=lineStr.left(lineStr.length()-1);
                  outDlg->OutputEdit->append(lineStr);
                  outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
              }
          }
          pclose(fp);
          sleep(1);
          
          outDlg->OutputEdit->append(tr("You can now close the output window."));
          outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
 //          outDlg->close();
 //            if(outDlg)
 //            delete outDlg;
      }
          break;
    };
 }
 bool FormatterApp::doFdisk() {
    return FALSE;
    
 }
 void FormatterApp::fillCombos() {
    StorageInfo storageInfo;
    const QList<FileSystem> &fs = storageInfo.fileSystems();
    QListIterator<FileSystem> it ( fs );
    QString storage;
    for( ; it.current(); ++it ){
        const QString name = (*it)->name();
        const QString path = (*it)->path();
        const QString disk = (*it)->disk();
        const QString options = (*it)->options();
        if( name.find( tr("Internal"),0,TRUE) == -1) {
            storageComboBox->insertItem(name +" -> "+disk);
        }
 //        deviceComboBox->insertItem(disk);
    }
    parsetab("/etc/mtab");
 //    parsetab("/etc/fstab");
    fileSystemsCombo->insertStringList( fsList,-1);
    deviceComboBox->insertStringList( deviceList,-1);
    storageComboSelected(0);
    deviceComboSelected(0); 
 }
 void FormatterApp::fsComboSelected(int index) {
 }
    
 void FormatterApp::storageComboSelected(int index ) {
    QString currentText = storageComboBox->text(index);
    QString nameS = currentText.left( currentText.find("->",0,TRUE));
    TextLabel4->setText( tr( "Storage Type : ") + nameS );
    currentText = currentText.right( currentText.length() - currentText.find(" -> ",0,TRUE) - 4);
    QString fsType = getFileSystemType((const QString &) currentText);
 //    qDebug(fsType);
    for(int i = 0; i < fileSystemsCombo->count(); i++) {
        if( fsType == fileSystemsCombo->text(i))
            fileSystemsCombo->setCurrentItem(i);
    }
 //    deviceComboSelected(index);     
 }
 void FormatterApp::deviceComboSelected(int index) {
    StorageInfo storageInfo;
    QString totalS, usedS, avS, diskS, nameS, fsType, selectedText;
    selectedText = deviceComboBox->text(index);
    const QList<FileSystem> &fs = storageInfo.fileSystems();
    QListIterator<FileSystem> it ( fs );
    QString storage;
    for( ; it.current(); ++it ){
        const QString name = (*it)->name();
        const QString path = (*it)->path();
        const QString disk = (*it)->disk();
 //              const QString options = (*it)->options();
        if( selectedText == disk) {
            diskS = disk; nameS= name;
            mountPointLineEdit->setText(path);
            long mult = (*it)->blockSize() / 1024;
            long div = 1024 / (*it)->blockSize();
            if ( !mult ) mult = 1;
            if ( !div ) div = 1;
            long total = (*it)->totalBlocks() * mult / div;
            long totalMb = total/1024;
            long avail = (*it)->availBlocks() * mult / div;
            long availMb = avail/1024;
            long used = total - avail;
            long usedMb = used/1024;
            totalS.sprintf(tr("Total: %1 kB ( %d mB)\n").arg( total ), totalMb );
            usedS.sprintf(tr("Used: %1 kB ( %d mB)\n").arg(used) ,usedMb);
            avS.sprintf( tr("Available: %1 kB ( %d mB)").arg(avail), availMb );
        }
    }
    fsType = getFileSystemType((const QString &)selectedText);
    TextLabel5->setText("Type: "+ nameS+"\nFormatted with "+ fsType + " \n" + totalS + usedS + avS);
 //     storageComboSelected(0);
 }
 void FormatterApp::cleanUp() {
 }
    
 void FormatterApp::editFstab() {
    QCopEnvelope e("QPE/Application/textedit","setDocument(QString)");
    e << (const QString &)"/etc/fstab";
 }
 void FormatterApp::parsetab(const QString &fileName) {
    fileSystemTypeList.clear();
    fsList.clear();
    struct mntent *me;
 //     if(fileName == "/etc/mtab") {
    FILE *mntfp = setmntent( fileName.latin1(), "r" );
    if ( mntfp ) {
        while ( (me = getmntent( mntfp )) != 0 ) {
            QString deviceName = me->mnt_fsname;
            QString filesystemType = me->mnt_type;
            if(deviceName != "none") {
                if( fsList.contains(filesystemType) == 0
                    & filesystemType.find("proc",0,TRUE) == -1
                    & filesystemType.find("cramfs",0,TRUE) == -1
                    & filesystemType.find("auto",0,TRUE) == -1)
                    fsList << filesystemType;
                deviceList << deviceName;
                qDebug(deviceName+"::"+filesystemType);
                fileSystemTypeList << deviceName+"::"+filesystemType;
            }
        }
    }
    endmntent( mntfp );
 //  } else if(fileName == "/etc/fstab") {
 //    QFile f("/etc/fstab");
 //   if ( f.open(IO_ReadOnly) ) {
 //     QTextStream t (&f);
 //     QString s;
 //     while (! t.eof()) {
 //         s=t.readLine();
 //         s=s.simplifyWhiteSpace();
 //         if ( (!s.isEmpty() ) && (s.find(" ")!=0) ) {
 // // = me->mnt_fsname;
 //             QString filesystemType = me->mnt_type;
 //             QString deviceName = s.left(0,s.find(BLANK) ); 
 //             s=s.remove(0,s.find(BLANK)+1 ); // devicename
          
 //             s=s.remove(0,s.find(BLANK)+1 ); // mountpoint
 //             QStringt mountPoint= s.left(0,s.find(BLANK) ); 
 //             s=s.remove(0,s.find(BLANK)+1 ); // fs
 //             QString filesystemType= s.left(0,s.find(BLANK) );           
 //         }
 //     }
 //  }
 //  f.close();
 // }
 }
 QString FormatterApp::getFileSystemType(const QString &currentText) {
    parsetab("/etc/mtab"); //why did TT forget filesystem type?
    for ( QStringList::Iterator it = fileSystemTypeList.begin(); it != fileSystemTypeList.end(); ++it ) {
        QString temp = (*it);
        if( temp.find( currentText,0,TRUE) != -1) {
            return temp.right( temp.length() - temp.find("::",0,TRUE) - 2);
 //                qDebug(fsType);
        }
    }
    return "";
 }
 bool FormatterApp::doFsck() {
    Output *outDlg;
    QString selectedDevice;
-// #if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX) 
+// #if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) 
    selectedDevice = deviceComboBox->currentText();
    QString mountPoint = mountPointLineEdit->text();
    QString umountS = "umount -v "+mountPoint+" 2>&1";
    QString remountS = "mount -v "+mountPoint+" 2>&1";
 // #else
 //       // for testing
 // //    currentText  = diskDevice  = "/dev/fd0";
 //     QString umountS = "umount -v /floppy 2>&1";
 //     QString remountS = "mount -v /floppy 2>&1";
 //     selectedDevice ="/dev/fd0";
  
 // #endif
    QString fsType = getFileSystemType((const QString &)selectedDevice);
    QString cmd;
    qDebug( selectedDevice +" "+ fsType);
    if(fsType == "vfat") cmd = "dosfsck -vy ";
    if(fsType == "ext2") cmd = "e2fsck -cpvy ";
    cmd += selectedDevice + " 2>&1";
    outDlg = new Output(this, tr("Formatter Output"),FALSE);
    outDlg->showMaximized();
    outDlg->show();
    qApp->processEvents();
    FILE *fp;
    char line[130];
    outDlg->OutputEdit->append( tr("Trying to umount."));
    outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
    sleep(1);
 //          qDebug("Command is "+umountS);
    fp = popen(  (const char *) umountS, "r");
 //          qDebug("%d", fp);
    if ( !fp ) {
        qDebug("Could not execute '" + umountS + "'!\n" +(QString)strerror(errno)); 
        QMessageBox::warning( this, tr("Formatter"), tr("umount failed!"), tr("&OK") );
        pclose(fp);             
        return false;
    } else {
 //             outDlg->OutputEdit->append( currentText + tr("\nhas been successfully umounted."));
 //             outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
        while ( fgets( line, sizeof line, fp)) {
            if( ((QString)line).find("busy",0,TRUE) != -1) {
                qDebug("Could not find '" + umountS); 
                QMessageBox::warning( this, tr("Formatter"),
                                      tr("Could not umount.\nDevice is busy!"), tr("&OK") );
                pclose(fp);             
                return false;
            } else {
                QString lineStr = line;
                lineStr=lineStr.left(lineStr.length()-1);
                outDlg->OutputEdit->append(lineStr);
                outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
            }
        }
    }
    pclose(fp);             
 /////////////////////////////////////
    fp = popen(  (const char *) cmd, "r"); 
    while ( fgets( line, sizeof line, fp)) {
        if( ((QString)line).find("No such device",0,TRUE) != -1) {
            qDebug("No such device '" + umountS); 
            QMessageBox::warning( this, tr("Formatter"), tr("No such device!"), tr("&OK") );
            pclose(fp);             
 //               outDlg->OutputEdit->append("No such device");
 //             outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
            return false;
        } else {
            QString lineStr = line;
            lineStr=lineStr.left(lineStr.length()-1);
            outDlg->OutputEdit->append(lineStr);
            outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
        }
    }
    outDlg->OutputEdit->append(tr("You can now close the output window."));
    outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
 //           outDlg->OutputEdit->append( currentText + tr("\nhas been successfully formatted."));
 //           outDlg->OutputEdit->setCursorPosition(outDlg->OutputEdit->numLines() + 1,0,FALSE);
    pclose(fp);             
 /////////////////////////////////////////    
    return true;
 }
 bool FormatterApp::doFsckCheck() {
    return FALSE;
 }
 int FormatterApp::formatCheck(const QString &deviceStr) {
    return -1;
 }
 int FormatterApp::runCommand(const QString &command) {
    return -1;
 }
diff --git a/qt/qconfig-qpe.h b/qt/qconfig-qpe.h
index 2b05f90..30d8190 100644
--- a/qt/qconfig-qpe.h
+++ b/qt/qconfig-qpe.h
@@ -1,99 +1,99 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef QT_H
 #endif // QT_H
 // Empty leaves all features enabled.  See doc/html/features.html for choices.
 // Note that disabling some features will produce a libqt that is not
 // compatible with other libqt builds. Such modifications are only
 // supported on Qt/Embedded where reducing the library size is important
 // and where the application-suite is often a fixed set.
 #ifndef QT_DLL
 #define QT_DLL // Internal
 #endif
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_EBX)
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_SL5XXX)
 # define QT_NO_QWS_CURSOR
 # define QT_NO_QWS_MOUSE_AUTO
 #endif
 #ifndef QT_NO_CODECS
 #define QT_NO_CODECS
 #endif
 #define QT_NO_UNICODETABLES
 //#define QT_NO_IMAGEIO_BMP
 #define QT_NO_IMAGEIO_PPM
 //#define QT_NO_ASYNC_IO
 //#define QT_NO_ASYNC_IMAGE_IO
 #define QT_NO_FREETYPE
 #define QT_NO_BDF
 //#define QT_NO_FONTDATABASE
 #define QT_NO_DRAGANDDROP
 //#define QT_NO_CLIPBOARD
 #define QT_NO_PROPERTIES
 #define QT_NO_NETWORKPROTOCOL
 #define QT_NO_IMAGE_TEXT
 //#define QT_NO_TOOLTIP
 #define QT_NO_COLORNAMES
 #define QT_NO_TRANSFORMATIONS
 #define QT_NO_TRANSLATION_BUILDER
 #define QT_NO_COMPLEXTEXT
 #define QT_NO_PRINTER
 #define QT_NO_PICTURE
 //#define QT_NO_ICONVIEW
 #define QT_NO_DIAL
 #define QT_NO_SIZEGRIP
 #define QT_NO_WORKSPACE
 //#define QT_NO_TABLE
 //#define QT_NO_ACTION
 //#define QT_NO_SETTINGS
 #define QT_NO_STYLE_POCKETPC
 #ifndef QT_NO_STYLE_AQUA
 # define QT_NO_STYLE_AQUA
 #endif
 #define QT_NO_STYLE_MOTIF
 #define QT_NO_STYLE_PLATINUM
 #define QT_NO_FILEDIALOG
 #define QT_NO_FONTDIALOG
 #define QT_NO_PRINTDIALOG
 #define QT_NO_COLORDIALOG
 #define QT_NO_INPUTDIALOG
 //#define QT_NO_MESSAGEBOX
 #define QT_NO_PROGRESSDIALOG
 //#define QT_NO_TABDIALOG
 #define QT_NO_WIZARD
 #define QT_NO_EFFECTS
 //#define QT_NO_COMPONENT
 #define QT_NO_DOM
 #define QT_NO_SEMIMODAL
 //#define QT_NO_PROGRESSBAR
 #define QT_NO_SPLITTER
 //#define QT_NO_QWS_SAVEFONTS
 //#define QT_NO_QWS_PROPERTIES
 #define QT_NO_QWS_BEOS_WM_STYLE
 #define QT_NO_QWS_KDE2_WM_STYLE
 #define QT_NO_QWS_KDE_WM_STYLE
 #define QT_NO_QWS_WINDOWS_WM_STYLE
diff --git a/x11/libqpe-x11/qpe/qpeapplication.cpp b/x11/libqpe-x11/qpe/qpeapplication.cpp
index ed815f8..eb01e50 100644
--- a/x11/libqpe-x11/qpe/qpeapplication.cpp
+++ b/x11/libqpe-x11/qpe/qpeapplication.cpp
@@ -502,294 +502,294 @@ void QPEApplication::internalSetStyle( const QString& ) {
 void QPEApplication::systemMessage( const QCString& chan, const QByteArray& ) {
    qWarning("QPEApplication::systemMessage( %s )", chan.data() );
 }
 void QPEApplication::pidMessage( const QCString& msg, const QByteArray& ) {
    if ( msg == "flush()" ) {
        emit flush();
        QCopEnvelope e( "QPE/Desktop", "flushDone(QString)" );
        e << d->appName;
    }else if ( msg == "reload()" ) {
        emit reload();
    }
 }
 void QPEApplication::timerEvent( QTimerEvent* e ) {
    if ( e->timerId() == d->presstimer && d->presswidget ) {
        // Right pressed
        postEvent( d->presswidget,
                   new QMouseEvent( QEvent::MouseButtonPress, d->presspos,
                                    RightButton, LeftButton ) );
        killTimer( d->presstimer );
        d->presstimer = 0;
    }
 }
 // InputMethods Hints
 namespace {
    static QPtrDict<void>* inputMethodDict = 0;
    static void createInputMethodDict(){
        if ( !inputMethodDict )
            inputMethodDict = new QPtrDict<void>;
    }
    static QPtrDict<void>* stylusDict = 0;
    static void createDict() {
        if ( !stylusDict )
            stylusDict = new QPtrDict<void>;
    }
 };
 void QPEApplication::setInputMethodHint( QWidget* w, InputMethodHint mode ) {
    createInputMethodDict();
    if ( mode == Normal ) {
        inputMethodDict->remove
            ( w );
    }else {
        inputMethodDict->insert( w, ( void* ) mode );
    }
 }
 QPEApplication::InputMethodHint QPEApplication::inputMethodHint( QWidget* w) {
    if ( inputMethodDict && w )
        return ( InputMethodHint ) ( int ) inputMethodDict->find( w );
    return Normal;
 }
 void QPEApplication::removeSenderFromStylusDict() {
    stylusDict->remove( ( void* ) sender() );
    if ( d->presswidget == sender() )
        d->presswidget = 0;
 }
 void QPEApplication::setStylusOperation( QWidget* w, StylusMode mode) {
    createDict();
    if ( mode == LeftOnly ) {
        stylusDict->remove
            ( w );
        w->removeEventFilter( qApp );
    }else {
        stylusDict->insert( w, ( void* ) mode );
        connect( w, SIGNAL( destroyed() ), qApp, SLOT( removeSenderFromStylusDict() ) );
        w->installEventFilter( qApp );
    }
 }
 QPEApplication::StylusMode QPEApplication::stylusOperation( QWidget* w) {
    if ( stylusDict )
        return ( StylusMode ) ( int ) stylusDict->find( w );
    return LeftOnly;
 }
 // eventFilter......
 bool QPEApplication::eventFilter( QObject* o, QEvent* e ) {
    /*
     * We want our WM to show Ok and a X button
     * on dialogs
     * our part is to set the _NET_WM_CONTEXT_ACCEPT
     * propery
     * and then wait for a client message -zecke
     * on show we will add the prop
     */
    if (o->inherits("QDialog") && e->type() == QEvent::Show ) {
        QDialog* dialog = (QDialog*)o;
        Atom wm_prot[45];
        int n = 0;
        wm_prot[n++] = d->wm_delete_window;
        wm_prot[n++] = d->wm_take_focus;
        wm_prot[n++] = d->wm_context_accept;
        if ( dialog->testWFlags( WStyle_ContextHelp ) )
            wm_prot[n++] = d->wm_context_help;
        XSetWMProtocols( qt_xdisplay(), dialog->winId(), wm_prot, n );
        return TRUE; // should be save
    }
    if ( stylusDict && e->type() >= QEvent::MouseButtonPress && e->type() <= QEvent::MouseMove ) {
        QMouseEvent * me = ( QMouseEvent* ) e;
        StylusMode mode = (StylusMode)(int)stylusDict->find(o);
        switch (mode) {
        case RightOnHold:
            switch ( me->type() ) {
            case QEvent::MouseButtonPress:
                if ( me->button() == LeftButton ) {
                    d->presstimer = startTimer(500); // #### pref.
                    d->presswidget = (QWidget*)o;
                    d->presspos = me->pos();
                    d->rightpressed = FALSE;
                }
                break;
            case QEvent::MouseMove:
                if (d->presstimer && (me->pos() - d->presspos).manhattanLength() > 8) {
                    killTimer(d->presstimer);
                    d->presstimer = 0;
                }
                break;
            case QEvent::MouseButtonRelease:
                if ( me->button() == LeftButton ) {
                    if ( d->presstimer ) {
                        killTimer(d->presstimer);
                        d->presstimer = 0;
                    }
                    if ( d->rightpressed && d->presswidget ) {
                        // Right released
                        postEvent( d->presswidget,
                                   new QMouseEvent( QEvent::MouseButtonRelease, me->pos(),
                                                    RightButton, LeftButton + RightButton ) );
                        // Left released, off-widget
                        postEvent( d->presswidget,
                                   new QMouseEvent( QEvent::MouseMove, QPoint( -1, -1),
                                                    LeftButton, LeftButton ) );
                        postEvent( d->presswidget,
                                   new QMouseEvent( QEvent::MouseButtonRelease, QPoint( -1, -1),
                                                    LeftButton, LeftButton ) );
                        d->rightpressed = FALSE;
                        return TRUE; // don't send the real Left release
                    }
                }
                break;
            default:
                break;
            }
            break;
        default:
            ;
        }
    }
    else if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
        QKeyEvent *ke = (QKeyEvent *)e;
        if ( ke->key() == Key_Enter ) {
            if ( o->isA( "QRadioButton" ) || o->isA( "QCheckBox" ) ) {
                postEvent( o, new QKeyEvent( e->type(), Key_Space, ' ',
                                             ke->state(), " ", ke->isAutoRepeat(), ke->count() ) );
                return TRUE;
            }
        }
    }
    return FALSE;
 }
 // Quit stuff
 void QPEApplication::restart() {
 }
 void QPEApplication::shutdown() {
 }
 void QPEApplication::tryQuit() {
    qWarning("TryQuit!!");
    if ( activeModalWidget() || strcmp( argv() [ 0 ], "embeddedkonsole" ) == 0 )
        return ; // Inside modal loop or konsole. Too hard to save state.
    {
        QCopEnvelope e( "QPE/System", "closing(QString)" );
        e << d->appName;
    }
    processEvents();
    quit();
 }
 void QPEApplication::hideOrQuit() {
    qWarning("hide or close");
    processEvents();
    qWarning("past processing");
    // If we are a preloaded application we don't actually quit, so emit
    // a System message indicating we're quasi-closing.
    if ( d->preloaded && d->qpe_main_widget )
    {
        qWarning("hiding");
        QCopEnvelope e("QPE/System", "fastAppHiding(QString)" );
        e << d->appName;
        d->qpe_main_widget->hide();
    }
    else
        quit();
 }
 /*!
  \internal
 */
 void QPEApplication::prepareForTermination( bool willrestart )
 {
        if ( willrestart ) {
                // Draw a big wait icon, the image can be altered in later revisions
                //  QWidget *d = QApplication::desktop();
                QImage img = Resource::loadImage( "launcher/new_wait" );
                QPixmap pix;
                pix.convertFromImage( img.smoothScale( 1 * img.width(), 1 * img.height() ) );
                QLabel *lblWait = new QLabel( 0, "wait hack!", QWidget::WStyle_Customize |
                                              QWidget::WStyle_NoBorder | QWidget::WStyle_Tool );
                lblWait->setPixmap( pix );
                lblWait->setAlignment( QWidget::AlignCenter );
                lblWait->show();
                lblWait->showMaximized();
        }
 #ifndef SINGLE_APP
        { QCopEnvelope envelope( "QPE/System", "forceQuit()" );
        }
        processEvents(); // ensure the message goes out.
        sleep( 1 ); // You have 1 second to comply.
 #endif
 }
 int QPEApplication::x11ClientMessage(QWidget* w, XEvent* event, bool b ) {
    qWarning("X11 ClientMessage %d %d", event->type,  ClientMessage);
    if ( event->type == ClientMessage ) {
        if ( (event->xclient.message_type == d->wm_protocols) &&
             (event->xclient.data.l[0] == d->wm_context_accept ) ) {
            qWarning("accepted!!!");
            /*
             * I'm not sure if we should use activeWidget
             * or activeModalWidget
             * a QDialog could be not modal too
             */
            if ( w->inherits("QDialog" ) ) {
                qWarning("inherits QDialog!!!");
                QDialog* dia = (QDialog*)w;
                /*
                 * call it directly or via QTimer::singleShot?
                 */
                QTimer::singleShot(0, dia, SLOT(accept() ) );
                 return 0;
            }
        }
    }
    return QApplication::x11ClientMessage(w, event, b );
 }
 #define KeyPress XKeyPress
 #define KeyRelease XKeyRelease
-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
+#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
 // The libraries with the skiff package (and possibly others) have
 // completely useless implementations of builtin new and delete that
 // use about 50% of your CPU. Here we revert to the simple libc
 // functions.
 void* operator new[]( size_t size )
 {
        return malloc( size );
 }
 void* operator new( size_t size )
 {
        return malloc( size );
 }
 void operator delete[]( void* p )
 {
        free( p );
 }
 void operator delete[]( void* p, size_t /*size*/ )
 {
        free( p );
 }
 void operator delete( void* p )
 {
        free( p );
 }
 void operator delete( void* p, size_t /*size*/ )
 {
        free( p );
 }
 #endif