34 files changed, 1 insertions, 110 deletions

diff --git a/noncore/multimedia/camera/gui/mainwindow.h b/noncore/multimedia/camera/gui/mainwindow.h
index 451ad5f..d93cca1 100644
--- a/noncore/multimedia/camera/gui/mainwindow.h
+++ b/noncore/multimedia/camera/gui/mainwindow.h
@@ -1,107 +1,105 @@
 /**********************************************************************
 ** Copyright (C) 2003 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Opie 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.
 **
 **********************************************************************/
 
 #ifndef MAINWINDOW_H
 #define MAINWINDOW_H
 
 #include <qmainwindow.h>
-#include <qdatetime.h>
 #include <qimage.h>
 #include <qpixmap.h>
-#include <qdatetime.h>
 
 class QAction;
 class QActionGroup;
 class QIconSet;
 class QTimerEvent;
 class QToolButton;
 class QLabel;
 class MainWindowBase;
 class QCopChannel;
 class PreviewWidget;
 
 class CameraMainWindow: public QMainWindow
 {
   Q_OBJECT
 
   public:
     CameraMainWindow( QWidget * parent = 0, const char * name = "mainwindow", WFlags f = 0 );
     virtual ~CameraMainWindow();
 
   public slots:
     void changeZoom( int );
     void systemMessage( const QCString&, const QByteArray& );
     void showContextMenu();
     void resoMenuItemClicked( QAction* );
     void qualityMenuItemClicked( QAction* );
     void zoomMenuItemClicked( QAction* );
     void flipMenuItemClicked( QAction* );
     void outputToMenuItemClicked( QAction* );
     void outputMenuItemClicked( QAction* );
     void prefixItemChoosen();
     void appendSettingsChoosen();
     void shutterClicked();
 
     void updateCaption();
 
   protected:
     void init();
     void startVideoCapture();
     void stopVideoCapture();
     void postProcessVideo( const QString&, const QString& );
     void performCapture( const QString& );
 
     virtual void timerEvent( QTimerEvent* );
 
   protected slots:
     void doSomething();     // solely for debugging purposes
 
   private:
     PreviewWidget* preview;
     int _rotation;
     QCopChannel* _sysChannel;
 
     QActionGroup* resog;
     QActionGroup* qualityg;
     QActionGroup* zoomg;
     QActionGroup* flipg;
     QActionGroup* outputTog;
     QAction* custom;
     QAction* docfolder;
     QActionGroup* outputg;
 
     QString flip;
     int quality;
     int zoom;
     int captureX;
     int captureY;
     QString captureFormat;
 
     QString outputTo;
     QString prefix;
     bool appendSettings;
 
     bool _capturing;
     int _pics;
     int _videos;
 
     QTime _time;
     int _videopics;
     int _capturefd;
     int _framerate;
     unsigned char* _capturebuf;
 };
 
 #endif
diff --git a/noncore/multimedia/opieplayer2/audiowidget.cpp b/noncore/multimedia/opieplayer2/audiowidget.cpp
index f3eafab..452117c 100644
--- a/noncore/multimedia/opieplayer2/audiowidget.cpp
+++ b/noncore/multimedia/opieplayer2/audiowidget.cpp
@@ -1,326 +1,324 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include "audiowidget.h"
-#include "mediaplayerstate.h"
-#include "playlistwidget.h"
 
 #include <qpe/qpeapplication.h>
 
 namespace
 {
 
 const int xo = -2; // movable x offset
 const int yo = 22; // movable y offset
 
 const MediaWidget::SkinButtonInfo skinInfo[] =
 {
     { MediaWidget::Play, "play", MediaWidget::ToggleButton },
     { MediaWidget::Stop, "stop", MediaWidget::NormalButton },
     { MediaWidget::Next, "next", MediaWidget::NormalButton },
     { MediaWidget::Previous, "prev", MediaWidget::NormalButton },
     { MediaWidget::VolumeUp, "up", MediaWidget::NormalButton },
     { MediaWidget::VolumeDown, "down", MediaWidget::NormalButton },
     { MediaWidget::Loop, "loop", MediaWidget::ToggleButton },
     { MediaWidget::PlayList, "playlist", MediaWidget::NormalButton },
     { MediaWidget::Forward, "forward", MediaWidget::NormalButton },
     { MediaWidget::Back, "back", MediaWidget::NormalButton }
 };
 
 const uint buttonCount = sizeof( skinInfo ) / sizeof( skinInfo[ 0 ] );
 
 void changeTextColor( QWidget * w) {
    QPalette p = w->palette();
    p.setBrush( QColorGroup::Background, QColor( 167, 212, 167 ) );
    p.setBrush( QColorGroup::Base, QColor( 167, 212, 167 ) );
    w->setPalette( p );
 }
 
 }
 
 AudioWidget::AudioWidget( PlayListWidget &playList, MediaPlayerState &mediaPlayerState, QWidget* parent, const char* name) :
 
     MediaWidget( playList, mediaPlayerState, parent, name ), songInfo( this ), slider( Qt::Horizontal, this ),  time( this ),
     audioSliderBeingMoved( false )
 {
     setCaption( tr("OpiePlayer") );
 
     loadSkin();
 
     connect( &mediaPlayerState, SIGNAL( loopingToggled(bool) ), this, SLOT( setLooping(bool) ) );
     connect( &mediaPlayerState, SIGNAL( isSeekableToggled(bool) ), this, SLOT( setSeekable(bool) ) );
 
     connect( this,  SIGNAL( forwardClicked() ), this, SLOT( skipFor() ) );
     connect( this,  SIGNAL( backClicked() ),  this, SLOT( skipBack() ) );
     connect( this,  SIGNAL( forwardReleased() ), this, SLOT( stopSkip() ) );
     connect( this,  SIGNAL( backReleased() ), this, SLOT( stopSkip() ) );
 
     // Intialise state
     setLength( mediaPlayerState.length() );
     setPosition( mediaPlayerState.position() );
     setLooping( mediaPlayerState.isFullscreen() );
     //    setPaused( mediaPlayerState->paused() );
     setPlaying( mediaPlayerState.isPlaying() );
 }
 
 AudioWidget::~AudioWidget() {
 
 //    mediaPlayerState->setPlaying(false);
 }
 
 MediaWidget::GUIInfo AudioWidget::guiInfo()
 {
     return GUIInfo( QString::null /* infix */, ::skinInfo, ::buttonCount );
 }
 
 void AudioWidget::resizeEvent( QResizeEvent *e ) {
     int h = height();
     int w = width();
 
     songInfo.setGeometry( QRect( 2, 2, w - 4, 20 ) );
     slider.setFixedWidth( w - 110 );
     slider.setGeometry( QRect( 15, h - 22, w - 90, 20 ) );
     slider.setBackgroundOrigin( QWidget::ParentOrigin );
     time.setGeometry( QRect( w - 85, h - 30, 70, 20 ) );
 
     upperLeftOfButtonMask.rx() = ( w - buttonUpImage.width() ) / 2;
     upperLeftOfButtonMask.ry() = (( h - buttonUpImage.height() ) / 2) - 10;
 
     MediaWidget::resizeEvent( e );
 }
 
 void AudioWidget::sliderPressed() {
     audioSliderBeingMoved = TRUE;
 }
 
 
 void AudioWidget::sliderReleased() {
     audioSliderBeingMoved = FALSE;
     if ( slider.width() == 0 )
   return;
     long val = long((double)slider.value() * mediaPlayerState.length() / slider.width());
     mediaPlayerState.setPosition( val );
 }
 
 void AudioWidget::setPosition( long i ) {
     //    qDebug("<<<<<<<<<<<<<<<<<<<<<<<<set position %d",i);
     updateSlider( i, mediaPlayerState.length() );
 }
 
 
 void AudioWidget::setLength( long max ) {
     updateSlider( mediaPlayerState.position(), max );
 }
 
 
 void AudioWidget::setDisplayType( MediaPlayerState::DisplayType mediaType ) {
     if ( mediaType == MediaPlayerState::Audio ) {
         // startTimer( 150 );
         QPEApplication::showWidget( this );
         return;
     }
 
     killTimers();
     hide();
 }
 
 void AudioWidget::loadSkin()
 {
     loadDefaultSkin( guiInfo() );
 
     songInfo.setFocusPolicy( QWidget::NoFocus );
 //    changeTextColor( &songInfo );
 //    songInfo.setBackgroundColor( QColor( 167, 212, 167 ));
 //    songInfo.setFrameStyle( QFrame::NoFrame);
     songInfo.setFrameStyle( QFrame::WinPanel | QFrame::Sunken );
 //    songInfo.setForegroundColor(Qt::white);
 
     slider.setFixedHeight( 20 );
     slider.setMinValue( 0 );
     slider.setMaxValue( 1 );
     slider.setFocusPolicy( QWidget::NoFocus );
     slider.setBackgroundPixmap( backgroundPixmap );
 
 //     Config cofg("qpe");
 //     cofg.setGroup("Appearance");
 //     QColor backgroundcolor = QColor( cofg.readEntry( "Background", "#E5E1D5" ) );
 
     time.setFocusPolicy( QWidget::NoFocus );
     time.setAlignment( Qt::AlignCenter );
 
 //    time.setFrame(FALSE);
 //    changeTextColor( &time );
 
     resizeEvent( 0 );
 }
 
 void AudioWidget::setSeekable( bool isSeekable ) {
 
     if ( !isSeekable ) {
         qDebug("<<<<<<<<<<<<<<file is STREAMING>>>>>>>>>>>>>>>>>>>");
         if( !slider.isHidden()) {
             slider.hide();
         }
         disconnect( &mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
         disconnect( &mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
         disconnect( &slider, SIGNAL( sliderPressed() ), this, SLOT( sliderPressed() ) );
         disconnect( &slider, SIGNAL( sliderReleased() ), this, SLOT( sliderReleased() ) );
     } else {
         // this stops the slider from being moved, thus
         // does not stop stream when it reaches the end
         slider.show();
         qDebug( " CONNECT SET POSTION " );
         connect( &mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
         connect( &mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
         connect( &slider, SIGNAL( sliderPressed() ), this, SLOT( sliderPressed() ) );
         connect( &slider, SIGNAL( sliderReleased() ), this, SLOT( sliderReleased() ) );
     }
 }
 
 
 static QString timeAsString( long length ) {
     int minutes = length / 60;
     int seconds = length % 60;
     return QString("%1:%2%3").arg( minutes ).arg( seconds / 10 ).arg( seconds % 10 );
 }
 
 void AudioWidget::updateSlider( long i, long max ) {
 
     time.setText( timeAsString( i ) + " / " + timeAsString( max ) );
 //    qDebug( timeAsString( i ) + " / " + timeAsString( max ) ) ;
 
     if ( max == 0 ) {
         return;
     }
     // Will flicker too much if we don't do this
     // Scale to something reasonable
     int width = slider.width();
     int val = int((double)i * width / max);
     if ( !audioSliderBeingMoved ) {
         if ( slider.value() != val ) {
             slider.setValue( val );
         }
 
         if ( slider.maxValue() != width ) {
             slider.setMaxValue( width );
         }
     }
 }
 
 void AudioWidget::skipFor() {
     skipDirection = +1;
     startTimer( 50 );
     mediaPlayerState.setPosition( mediaPlayerState.position() + 2 );
 }
 
 void AudioWidget::skipBack() {
     skipDirection = -1;
     startTimer( 50 );
     mediaPlayerState.setPosition( mediaPlayerState.position() - 2 );
 }
 
 
 
 void AudioWidget::stopSkip() {
     killTimers();
 }
 
 
 void AudioWidget::timerEvent( QTimerEvent * ) {
     if ( skipDirection == +1 ) {
         mediaPlayerState.setPosition( mediaPlayerState.position() + 2 );
     }  else if ( skipDirection == -1 ) {
         mediaPlayerState.setPosition( mediaPlayerState.position() - 2 );
     }
 }
 
 void AudioWidget::keyReleaseEvent( QKeyEvent *e) {
     switch ( e->key() ) {
         ////////////////////////////// Zaurus keys
       case Key_Home:
           break;
       case Key_F9: //activity
            hide();
            //           qDebug("Audio F9");
            e->accept();
           break;
       case Key_F10: //contacts
           break;
       case Key_F11: //menu
               mediaPlayerState.toggleBlank();
               e->accept();
           break;
       case Key_F12: //home
           break;
       case Key_F13: //mail
              mediaPlayerState.toggleBlank();
              e->accept();
           break;
       case Key_Space: {
           e->accept();
           mediaPlayerState.togglePaused();
       }
           break;
       case Key_Down:
           //              toggleButton(6);
           emit lessClicked();
           emit lessReleased();
           //          toggleButton(6);
           e->accept();
           break;
       case Key_Up:
           //             toggleButton(5);
            emit moreClicked();
            emit moreReleased();
            //             toggleButton(5);
            e->accept();
            break;
       case Key_Right:
           //            toggleButton(3);
           mediaPlayerState.setNext();
           //            toggleButton(3);
            e->accept();
           break;
       case Key_Left:
           //            toggleButton(4);
           mediaPlayerState.setPrev();
           //            toggleButton(4);
           e->accept();
           break;
       case Key_Escape: {
       }
           break;
 
     };
 }
diff --git a/noncore/multimedia/opieplayer2/inputDialog.cpp b/noncore/multimedia/opieplayer2/inputDialog.cpp
index ebde9c6..05dc2d1 100644
--- a/noncore/multimedia/opieplayer2/inputDialog.cpp
+++ b/noncore/multimedia/opieplayer2/inputDialog.cpp
@@ -1,74 +1,67 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002,2003 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include "inputDialog.h"
 
-#include <qpe/resource.h>
-#include <qpe/qpeapplication.h>
 
-#include <qfileinfo.h>
 #include <qlineedit.h>
-#include <qlayout.h>
-#include <qvariant.h>
-#include <qpushbutton.h>
-#include <qwhatsthis.h>
 
 InputDialog::InputDialog( QWidget* parent,  const char* name, bool modal, WFlags fl )
     : QDialog( parent, name, modal, fl ) {
     if ( !name ) {
         setName( "InputDialog" );
     }
     resize( 234, 115);
     setMaximumSize( QSize( 240, 40));
     setCaption( tr( name ) );
 
     QPushButton *browserButton;
     //browserButton = new QPushButton( Resource::loadIconSet("fileopen"),"",this,"BrowseButton");
     //browserButton->setGeometry( QRect( 205, 10, 22, 22));
     //connect( browserButton, SIGNAL(released()),this,SLOT(browse()));
     LineEdit1 = new QLineEdit( this, "LineEdit1" );
     LineEdit1->setGeometry( QRect( 4, 10, 190, 22 ) );
     LineEdit1->setFocus();
 }
 /*
  * return the current text(input)
  */
 QString InputDialog::text() const {
    return LineEdit1->text();
 }
 /*
  *  Destroys the object and frees any allocated resources
  */
 InputDialog::~InputDialog() {
 }
 
diff --git a/noncore/multimedia/opieplayer2/lib.cpp b/noncore/multimedia/opieplayer2/lib.cpp
index 664ec65..a42b8e5 100644
--- a/noncore/multimedia/opieplayer2/lib.cpp
+++ b/noncore/multimedia/opieplayer2/lib.cpp
@@ -1,433 +1,432 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 LJP <>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include <qtextstream.h>
 
 #include <qdir.h>
 
 #include <qgfx_qws.h>
-#include <qdirectpainter_qws.h>
 
 #include <assert.h>
 
 #include "xinevideowidget.h"
 #include "frame.h"
 #include "lib.h"
 
 
 typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame,
                                       int  width, int height,int bytes );
 
 extern "C" {
     xine_vo_driver_t* init_video_out_plugin( xine_t *xine, void* video, display_xine_frame_t, void * );
     int null_is_showing_video( const xine_vo_driver_t* self );
     void null_set_show_video( const xine_vo_driver_t* self, int show );
     int null_is_fullscreen( const xine_vo_driver_t* self );
     void null_set_fullscreen( const xine_vo_driver_t* self, int screen );
     int null_is_scaling( const xine_vo_driver_t* self );
     void null_set_scaling( const xine_vo_driver_t* self, int scale );
     void null_set_gui_width( const xine_vo_driver_t* self, int width );
     void null_set_gui_height( const xine_vo_driver_t* self, int height );
     void null_set_mode( const xine_vo_driver_t* self, int depth,  int rgb  );
     void null_set_videoGamma( const  xine_vo_driver_t* self , int value );
     void null_display_handler( const xine_vo_driver_t* self, display_xine_frame_t t, void* user_data );
 
     void null_preload_decoders( xine_stream_t *stream );
 }
 
 using namespace XINE;
 
 Lib::Lib( InitializationMode initMode, XineVideoWidget* widget )
 {
     m_initialized = false;
     m_duringInitialization = false;
     m_video = false;
     m_wid = widget;
     printf("Lib");
     QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf";
     // get the configuration
 
     // not really OO, should be an extra class, later
     if ( !QFile::exists(configPath) ) {
         QFile f(configPath);
         f.open(IO_WriteOnly);
         QTextStream ts( &f );
         ts << "misc.memcpy_method:glibc\n";
         ts << "# uncomment if you experience double speed audio \n #audio.oss_sync_method:softsync\n";
         ts << "codec.ffmpeg_pp_quality:3\n";
         ts << "audio.num_buffers:50\n";
         ts << "audio.size_buffers:4096\n";
         ts << "video.num_buffers:20\n";
         ts << "video.size_buffers:4096\n";
         ts << "audio.out_num_audio_buf:16\n";
         ts << "audio.out_size_audio_buf:8096\n";
         ts << "audio.out_size_zero_buf:1024\n";
         ts << "audio.passthrough_offset:0\n";
         f.close();
     }
 
     if ( initMode == InitializeImmediately ) {
         initialize();
         m_initialized = true;
     }
     else
         start();
 }
 
 void Lib::run()
 {
     qDebug( "Lib::run() started" );
     initialize();
     m_initialized = true;
     qDebug( "Lib::run() finished" );
 }
 
 void Lib::initialize()
 {
     m_duringInitialization = true;
     m_xine =  xine_new( );
 
     QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf";
     xine_config_load( m_xine, QFile::encodeName( configPath ) );
 
     xine_init( m_xine );
 
     // allocate oss for sound
     // and fb for framebuffer
     m_audioOutput = xine_open_audio_driver( m_xine,  "oss", NULL );
     m_videoOutput = ::init_video_out_plugin( m_xine, NULL, xine_display_frame, this );
 
 
 //xine_open_video_driver( m_xine,  NULL,  XINE_VISUAL_TYPE_FB,  NULL);
 
 
 //    null_display_handler( m_videoOutput, xine_display_frame, this );
 
     m_stream = xine_stream_new (m_xine,  m_audioOutput,  m_videoOutput );
 
     if (m_wid != 0 ) {
         printf( "!0\n" );
         setWidget( m_wid );
     }
 
     m_queue = xine_event_new_queue (m_stream);
 
     xine_event_create_listener_thread (m_queue, xine_event_handler, this);
 
       ::null_preload_decoders( m_stream );
 
     m_duringInitialization = false;
 }
 
 Lib::~Lib() {
     assert( isRunning() == false );
     assert( m_initialized );
 
 //    free( m_config );
 
     xine_close( m_stream );
 
     xine_event_dispose_queue( m_queue );
 
     xine_dispose( m_stream );
 
     xine_exit( m_xine );
     /* FIXME either free or delete but valgrind bitches against both */
     //free( m_videoOutput );
     //delete m_audioOutput;
 }
 
 void Lib::resize ( const QSize &s ) {
     assert( m_initialized || m_duringInitialization );
 
     if ( s. width ( ) && s. height ( ) ) {
         ::null_set_gui_width( m_videoOutput,  s. width() );
         ::null_set_gui_height( m_videoOutput,  s. height() );
     }
 }
 
 int Lib::majorVersion() {
      int major, minor, sub;
      xine_get_version ( &major, &minor, &sub );
      return major;
 }
 
 int Lib::minorVersion() {
      int major, minor, sub;
      xine_get_version ( &major, &minor, &sub );
      return minor;
 }
 
 int Lib::subVersion() {
      int major, minor, sub;
      xine_get_version ( &major, &minor, &sub );
      return sub;
 }
 
 int Lib::play( const QString& fileName, int startPos, int start_time ) {
     assert( m_initialized );
     // FIXME actually a hack imho. Should not be needed to dispose the whole stream
     // but without we get wrong media length reads from libxine for the second media
     //xine_dispose ( m_stream );
 
     QString str = fileName.stripWhiteSpace();
 
     //m_stream = xine_stream_new (m_xine,  m_audioOutput,  m_videoOutput );
     //m_queue = xine_event_new_queue (m_stream);
     //xine_event_create_listener_thread (m_queue, xine_event_handler, this);
 
      if ( !xine_open( m_stream, str.utf8().data() ) ) {
         return 0;
     }
     return xine_play( m_stream, startPos, start_time);
 }
 
 void Lib::stop() {
     assert( m_initialized );
 
     qDebug("<<<<<<<< STOP IN LIB TRIGGERED >>>>>>>");
     xine_stop( m_stream );
 }
 
 void Lib::pause( bool toggle ) {
     assert( m_initialized );
 
     xine_set_param( m_stream, XINE_PARAM_SPEED, toggle ? XINE_SPEED_PAUSE : XINE_SPEED_NORMAL );
 }
 
 int Lib::speed() const {
     assert( m_initialized );
 
     return  xine_get_param ( m_stream, XINE_PARAM_SPEED );
 }
 
 void Lib::setSpeed( int speed ) {
     assert( m_initialized );
 
     xine_set_param ( m_stream, XINE_PARAM_SPEED, speed );
 }
 
 int Lib::status() const {
     assert( m_initialized );
 
     return xine_get_status( m_stream );
 }
 
 int Lib::currentPosition() const {
     assert( m_initialized );
 
     int pos, time, length;
     xine_get_pos_length( m_stream, &pos, &time, &length );
     return pos;
 }
 
 int Lib::currentTime() const {
     assert( m_initialized );
 
     int pos, time, length;
     xine_get_pos_length( m_stream, &pos, &time, &length );
     if ( time > 0 )  {
         return time/1000;
     } else {
         return 0;
     }
 }
 
 int Lib::length() const {
       assert( m_initialized );
 
       int pos, time, length;
 /* dilb: patch to solve the wrong stream length reported to the GUI*/
       int iRetVal=0, iTestLoop=0;
 
       do
               {
         iRetVal = xine_get_pos_length( m_stream, &pos, &time, &length );
         if (iRetVal)
            {/* if the function didn't return 0, then pos, time and length are valid.*/
            return length/1000;
            }
         /*don't poll too much*/
         usleep(100000);
         iTestLoop++;
         }
       while ( iTestLoop < 10 ); /* if after 1s, we still don't have any
 valid stream, then return -1 (this value could be used to make the stream
 unseekable, but it should never occur!! Mr. Murphy ? :) ) */
 
       return -1;
 }
 
 bool Lib::isSeekable() const {
     assert( m_initialized );
 
     return xine_get_stream_info( m_stream, XINE_STREAM_INFO_SEEKABLE );
 }
 
 void Lib::seekTo( int time ) {
     assert( m_initialized );
 
     //xine_trick_mode ( m_stream, XINE_TRICK_MODE_SEEK_TO_TIME, time ); NOT IMPLEMENTED YET IN XINE :_(
     // since its now milliseconds we need *1000
     xine_play( m_stream, 0, time*1000 );
 }
 
 
 Frame Lib::currentFrame() const {
     assert( m_initialized );
 
     Frame frame;
     return frame;
 };
 
 QString Lib::metaInfo( int number) const {
     assert( m_initialized );
 
     return xine_get_meta_info( m_stream, number );
 }
 
 int Lib::error() const {
     assert( m_initialized );
 
     return xine_get_error( m_stream );
 };
 
 void Lib::ensureInitialized()
 {
     if ( m_initialized )
         return;
 
     qDebug( "waiting for initialization thread to finish" );
     wait();
     qDebug( "initialization thread finished!" );
 }
 
 void Lib::setWidget( XineVideoWidget *widget )
 {
     m_wid = widget;
     resize ( m_wid-> size ( ) );
     ::null_set_mode( m_videoOutput, qt_screen->depth(), qt_screen->pixelType() );
     m_wid->repaint();
 }
 
 void Lib::receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType )
 {
     assert( sendType == ThreadUtil::Channel::OneWay );
     handleXineEvent( msg->type() );
     delete msg;
 }
 
 void Lib::handleXineEvent( const xine_event_t* t ) {
     send( new ThreadUtil::ChannelMessage( t->type ), OneWay );
 }
 
 void Lib::handleXineEvent( int type ) {
     assert( m_initialized );
 
     if ( type == XINE_EVENT_UI_PLAYBACK_FINISHED ) {
         emit stopped();
     }
 }
 
 
 void Lib::setShowVideo( bool video ) {
     assert( m_initialized );
 
     m_video = video;
     ::null_set_show_video( m_videoOutput, video );
 }
 
 bool Lib::isShowingVideo() const {
     assert( m_initialized );
 
     return ::null_is_showing_video( m_videoOutput );
 }
 
 bool Lib::hasVideo() const {
     assert( m_initialized );
 
     return  xine_get_stream_info( m_stream, 18 );
 }
 
 void Lib::showVideoFullScreen( bool fullScreen ) {
     assert( m_initialized );
 
     ::null_set_fullscreen( m_videoOutput, fullScreen );
 }
 
 bool Lib::isVideoFullScreen() const {
     assert( m_initialized );
 
     return ::null_is_fullscreen( m_videoOutput );
 }
 
 void Lib::setScaling( bool scale ) {
     assert( m_initialized );
 
     ::null_set_scaling( m_videoOutput, scale );
 }
 
 void Lib::setGamma( int value ) {
     assert( m_initialized );
 
    ::null_set_videoGamma( m_videoOutput, value );
 }
 
 bool Lib::isScaling() const {
     assert( m_initialized );
 
     return ::null_is_scaling( m_videoOutput );
 }
 
 void Lib::xine_event_handler( void* user_data, const xine_event_t* t ) {
     ( (Lib*)user_data)->handleXineEvent( t );
 }
 
 void Lib::xine_display_frame( void* user_data, uint8_t *frame,
                               int width,  int height,  int bytes ) {
     ( (Lib*)user_data)->drawFrame( frame, width, height, bytes );
 }
 
 void Lib::drawFrame( uint8_t* frame,  int width,  int height,  int bytes ) {
     assert( m_initialized );
 
     if ( !m_video ) {
         qWarning("not showing video now");
         return;
     }
 
     assert( m_wid );
 
     m_wid-> setVideoFrame ( frame, width, height, bytes );
 }
diff --git a/noncore/multimedia/opieplayer2/main.cpp b/noncore/multimedia/opieplayer2/main.cpp
index b0a22b2..00f72d1 100644
--- a/noncore/multimedia/opieplayer2/main.cpp
+++ b/noncore/multimedia/opieplayer2/main.cpp
@@ -1,29 +1,26 @@
 
-#include <qpe/qpeapplication.h>
-#include "mediaplayerstate.h"
-#include "playlistwidget.h"
 #include "mediaplayer.h"
 
 
 
 #include <opie/oapplicationfactory.h>
 
 OPIE_EXPORT_APP( OApplicationFactory<PlayListWidget> )
 
 #if 0
 int main(int argc, char **argv) {
     QPEApplication a(argc,argv);
 
     MediaPlayerState st( 0, "mediaPlayerState" );
     PlayListWidget pl( st, 0, "playList" );
     pl.showMaximized();
     MediaPlayer mp( pl, st, 0, "mediaPlayer" );
     QObject::connect( &pl, SIGNAL( skinSelected() ),
                       &mp, SLOT( reloadSkins() ) );
 
     a.showMainDocumentWidget(&pl);
 
     return a.exec();
 }
 #endif
 
diff --git a/noncore/multimedia/opieplayer2/mediaplayer.cpp b/noncore/multimedia/opieplayer2/mediaplayer.cpp
index 1e6bc4d..a236775 100644
--- a/noncore/multimedia/opieplayer2/mediaplayer.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayer.cpp
@@ -1,405 +1,401 @@
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
-#include <qpe/qcopenvelope_qws.h>
 #include <qfileinfo.h>
 
 #include "mediaplayer.h"
-#include "playlistwidget.h"
 #include "audiowidget.h"
 #include "videowidget.h"
 #include "volumecontrol.h"
-#include "lib.h"
 
-#include "mediaplayerstate.h"
 
  // for setBacklight()
 #include <linux/fb.h>
 #include <sys/file.h>
 #include <sys/ioctl.h>
 
 
 #define FBIOBLANK             0x4611
 
 MediaPlayer::MediaPlayer( PlayListWidget &_playList, MediaPlayerState &_mediaPlayerState, QObject *parent, const char *name )
     : QObject( parent, name ), volumeDirection( 0 ), mediaPlayerState( _mediaPlayerState ), playList( _playList ) {
 
     m_audioUI = 0;
     m_videoUI = 0;
     m_xineControl = 0;
     xine = new XINE::Lib( XINE::Lib::InitializeInThread );
 
     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_SL5XXX
     fl= open( "/dev/fl", O_RDWR );
 #endif
     if (fd != -1) {
         if ( b ) {
             qDebug("do blanking");
 #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_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/multimedia/opieplayer2/mediaplayerstate.cpp b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
index 40fa1a4..203ff91 100644
--- a/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayerstate.cpp
@@ -1,264 +1,259 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 // this file is based on work by trolltech
 
-#include <qpe/qpeapplication.h>
-#include <qpe/qlibrary.h>
 #include <qpe/config.h>
-#include <qvaluelist.h>
-#include <qobject.h>
-#include <qdir.h>
 #include "mediaplayerstate.h"
 
 #include <assert.h>
 
 //#define MediaPlayerDebug(x) qDebug x
 #define MediaPlayerDebug(x)
 
 
 MediaPlayerState::MediaPlayerState( QObject *parent, const char *name )
         : QObject( parent, name ) {
     Config cfg( "OpiePlayer" );
     readConfig( cfg );
     streaming = false;
     seekable = true;
 }
 
 
 MediaPlayerState::~MediaPlayerState() {
 }
 
 
 void MediaPlayerState::readConfig( Config& cfg ) {
     cfg.setGroup("Options");
     fullscreen = cfg.readBoolEntry( "FullScreen" );
     scaled = cfg.readBoolEntry( "Scaling" );
     looping = cfg.readBoolEntry( "Looping" );
     shuffled = cfg.readBoolEntry( "Shuffle" );
     videoGamma = cfg.readNumEntry( "VideoGamma" );
     playing = FALSE;
     streaming = FALSE;
     paused = FALSE;
     curPosition = 0;
     curLength = 0;
     m_displayType = MediaSelection;
 }
 
 
 void MediaPlayerState::writeConfig( Config& cfg ) const {
     cfg.setGroup( "Options" );
     cfg.writeEntry( "FullScreen", fullscreen );
     cfg.writeEntry( "Scaling", scaled );
     cfg.writeEntry( "Looping", looping );
     cfg.writeEntry( "Shuffle", shuffled );
     cfg.writeEntry( "VideoGamma",  videoGamma );
 }
 
 MediaPlayerState::DisplayType MediaPlayerState::displayType() const
 {
     return m_displayType;
 }
 
 // slots
 void MediaPlayerState::setIsStreaming( bool b ) {
     streaming = b;
 }
 
 void MediaPlayerState::setIsSeekable( bool b ) {
     seekable = b;
     emit isSeekableToggled(b);
 }
 
 
 void MediaPlayerState::setFullscreen( bool b ) {
     if ( fullscreen == b ) {
         return;
     }
     fullscreen = b;
     emit fullscreenToggled(b);
 }
 
 
 void MediaPlayerState::setBlanked( bool b ) {
     if ( blanked == b ) {
         return;
     }
     blanked = b;
     emit blankToggled(b);
 }
 
 
 void MediaPlayerState::setScaled( bool b ) {
     if ( scaled == b ) {
         return;
     }
     scaled = b;
     emit scaledToggled(b);
 }
 
 void MediaPlayerState::setLooping( bool b ) {
     if ( looping    == b ) {
         return;
     }
     looping = b;
     emit loopingToggled(b);
 }
 
 void MediaPlayerState::setShuffled( bool b ) {
     if ( shuffled   == b ) {
         return;
     }
     shuffled = b;
     emit shuffledToggled(b);
 }
 
 void MediaPlayerState::setPaused( bool b ) {
       if ( paused  == b ) {
           paused = FALSE;
           emit pausedToggled(FALSE);
           return;
       }
      paused = b;
      emit pausedToggled(b);
 }
 
 void MediaPlayerState::setPlaying( bool b ) {
     if ( playing  == b ) {
         return;
     }
     playing = b;
     stopped = !b;
     emit playingToggled(b);
 }
 
 void MediaPlayerState::setStopped( bool b ) {
     if ( stopped  == b ) {
         return;
     }
     stopped = b;
     emit stopToggled(b);
 }
 
 void MediaPlayerState::setPosition( long p ) {
     if ( curPosition == p ) {
         return;
     }
     curPosition = p;
     emit positionChanged(p);
 }
 
 void MediaPlayerState::updatePosition( long p ){
     if ( curPosition  == p ) {
         return;
     }
     curPosition = p;
     emit positionUpdated(p);
 }
 
 void MediaPlayerState::setVideoGamma( int v ){
     if ( videoGamma  == v ) {
         return;
     }
     videoGamma = v;
     emit videoGammaChanged( v );
 }
 
 void MediaPlayerState::setLength( long l ) {
     if ( curLength  == l ) {
         return;
     }
     curLength = l;
     emit lengthChanged(l);
 }
 
 void MediaPlayerState::setDisplayType( DisplayType displayType )
 {
     if ( m_displayType == displayType )
         return;
 
     m_displayType = displayType;
     emit displayTypeChanged( m_displayType );
 }
 
 void MediaPlayerState::setPrev(){
     emit prev();
 }
 
 void MediaPlayerState::setNext() {
     emit next();
 }
 
 void MediaPlayerState::setList() {
     setPlaying( FALSE );
     setDisplayType( MediaSelection );
 }
 
 void MediaPlayerState::setVideo() {
     setDisplayType( Video );
 }
 
 void MediaPlayerState::setAudio() {
     setDisplayType( Audio );
 }
 
 void MediaPlayerState::toggleFullscreen() {
     setFullscreen( !fullscreen );
 }
 
 void MediaPlayerState::toggleScaled() {
     setScaled( !scaled);
 }
 
 void MediaPlayerState::toggleLooping() {
     setLooping( !looping);
 }
 
 void MediaPlayerState::toggleShuffled() {
     setShuffled( !shuffled);
 }
 
 void MediaPlayerState::togglePaused() {
     setPaused( !paused);
 }
 
 void MediaPlayerState::togglePlaying() {
     setPlaying( !playing);
 }
 
 void MediaPlayerState::toggleBlank() {
     setBlanked( !blanked);
 }
 
 
 
diff --git a/noncore/multimedia/opieplayer2/mediawidget.cpp b/noncore/multimedia/opieplayer2/mediawidget.cpp
index 08c62a2..563ccf5 100644
--- a/noncore/multimedia/opieplayer2/mediawidget.cpp
+++ b/noncore/multimedia/opieplayer2/mediawidget.cpp
@@ -1,263 +1,262 @@
 /*
    Copyright (C) 2002 Simon Hausmann <simon@lst.de>
              (C) 2002 Max Reiss <harlekin@handhelds.org>
              (C) 2002 L. Potter <ljp@llornkcor.com>
              (C) 2002 Holger Freyther <zecke@handhelds.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 
 #include <assert.h>
 
 #include "mediawidget.h"
-#include "playlistwidget.h"
 #include "skin.h"
 
 MediaWidget::MediaWidget( PlayListWidget &_playList, MediaPlayerState &_mediaPlayerState, QWidget *parent, const char *name )
     : QWidget( parent, name ), mediaPlayerState( _mediaPlayerState ), playList( _playList )
 {
     connect( &mediaPlayerState, SIGNAL( displayTypeChanged(MediaPlayerState::DisplayType) ),
              this, SLOT( setDisplayType(MediaPlayerState::DisplayType) ) );
     connect( &mediaPlayerState, SIGNAL( lengthChanged(long) ),
              this, SLOT( setLength(long) ) );
     connect( &mediaPlayerState, SIGNAL( playingToggled(bool) ),
              this, SLOT( setPlaying(bool) ) );
 
     setBackgroundMode( NoBackground );
 }
 
 MediaWidget::~MediaWidget()
 {
 }
 
 void MediaWidget::setupButtons( const SkinButtonInfo *skinInfo, uint buttonCount,
                                 const Skin &skin )
 {
     buttonMask = skin.buttonMask( skinInfo, buttonCount );
 
     buttons.clear();
     buttons.reserve( buttonCount );
 
     for ( uint i = 0; i < buttonCount; ++i ) {
         Button button = setupButton( skinInfo[ i ], skin );
         buttons.push_back( button );
     }
 }
 
 MediaWidget::Button MediaWidget::setupButton( const SkinButtonInfo &buttonInfo, const Skin &skin )
 {
     Button button;
     button.command = buttonInfo.command;
     button.type = buttonInfo.type;
     button.mask = skin.buttonMaskImage( buttonInfo.fileName );
 
     return button;
 }
 
 void MediaWidget::loadDefaultSkin( const GUIInfo &guiInfo )
 {
     Skin skin( guiInfo.fileNameInfix );
     skin.setCachable( false );
     loadSkin( guiInfo.buttonInfo, guiInfo.buttonCount, skin );
 }
 
 void MediaWidget::loadSkin( const SkinButtonInfo *skinInfo, uint buttonCount, const Skin &skin )
 {
     backgroundPixmap = skin.backgroundPixmap();
     buttonUpImage = skin.buttonUpImage();
     buttonDownImage = skin.buttonDownImage();
 
     setupButtons( skinInfo, buttonCount, skin );
 }
 
 void MediaWidget::closeEvent( QCloseEvent * )
 {
     mediaPlayerState.setList();
 }
 
 void MediaWidget::paintEvent( QPaintEvent *pe )
 {
     QPainter p( this );
 
     if ( mediaPlayerState.isFullscreen() ) {
         // Clear the background
         p.setBrush( QBrush( Qt::black ) );
         return;
     }
 
     QPixmap buffer( size() );
     QPainter bufferedPainter( &buffer );
     bufferedPainter.drawTiledPixmap( rect(), backgroundPixmap, QPoint( 0, 0 ) );
     paintAllButtons( bufferedPainter );
     p.drawPixmap( 0, 0, buffer );
 }
 
 void MediaWidget::resizeEvent( QResizeEvent *e )
 {
     QPixmap pixUp = combineImageWithBackground( buttonUpImage, backgroundPixmap, upperLeftOfButtonMask );
     QPixmap pixDn = combineImageWithBackground( buttonDownImage, backgroundPixmap, upperLeftOfButtonMask );
 
     for ( ButtonVector::iterator it = buttons.begin(); it != buttons.end(); ++it ) {
         Button &button = *it;
 
         if ( button.mask.isNull() )
             continue;
         button.pixUp = addMaskToPixmap( pixUp, button.mask );
         button.pixDown = addMaskToPixmap( pixDn, button.mask );
     }
 
     QWidget::resizeEvent( e );
 }
 
 MediaWidget::Button *MediaWidget::buttonAt( const QPoint &position )
 {
     if ( position.x() <= 0 || position.y() <= 0 ||
          position.x() >= buttonMask.width() ||
          position.y() >= buttonMask.height() )
         return 0;
 
     int pixelIdx = buttonMask.pixelIndex( position.x(), position.y() );
     for ( ButtonVector::iterator it = buttons.begin(); it != buttons.end(); ++it )
         if ( it->command + 1 == pixelIdx )
             return &( *it );
 
     return 0;
 }
 
 void MediaWidget::mousePressEvent( QMouseEvent *event )
 {
     Button *button = buttonAt( event->pos() - upperLeftOfButtonMask );
 
     if ( !button ) {
         QWidget::mousePressEvent( event );
         return;
     }
 
     switch ( button->command ) {
         case VolumeUp:   emit moreClicked(); return;
         case VolumeDown: emit lessClicked(); return;
         case Back:       emit backClicked(); return;
         case Forward:    emit forwardClicked(); return;
         default: break;
     }
 }
 
 void MediaWidget::mouseReleaseEvent( QMouseEvent *event )
 {
     Button *button = buttonAt( event->pos() - upperLeftOfButtonMask );
 
     if ( !button ) {
         QWidget::mouseReleaseEvent( event );
         return;
     }
 
     if ( button->type == ToggleButton )
         toggleButton( *button );
 
     handleCommand( button->command, button->isDown );
 }
 
 void MediaWidget::makeVisible()
 {
 }
 
 void MediaWidget::handleCommand( Command command, bool buttonDown )
 {
     switch ( command ) {
         case Play:       mediaPlayerState.togglePaused(); return;
         case Stop:       mediaPlayerState.setPlaying(FALSE); return;
         case Next:       if( playList.currentTab() == PlayListWidget::CurrentPlayList ) mediaPlayerState.setNext(); return;
         case Previous:   if( playList.currentTab() == PlayListWidget::CurrentPlayList ) mediaPlayerState.setPrev(); return;
         case Loop:       mediaPlayerState.setLooping( buttonDown ); return;
         case VolumeUp:   emit moreReleased(); return;
         case VolumeDown: emit lessReleased(); return;
         case PlayList:   mediaPlayerState.setList();  return;
         case Forward:    emit forwardReleased(); return;
         case Back:       emit backReleased(); return;
         case FullScreen: mediaPlayerState.setFullscreen( true ); makeVisible(); return;
         default: assert( false );
     }
 }
 
 bool MediaWidget::isOverButton( const QPoint &position, int buttonId ) const
 {
     return ( position.x() > 0 && position.y() > 0 && 
              position.x() < buttonMask.width() && 
              position.y() < buttonMask.height() && 
              buttonMask.pixelIndex( position.x(), position.y() ) == buttonId + 1 );
 }
 
 void MediaWidget::paintAllButtons( QPainter &p )
 {
     for ( ButtonVector::const_iterator it = buttons.begin();
           it != buttons.end(); ++it )
         paintButton( p, *it );
 }
 
 void MediaWidget::paintButton( const Button &button )
 {
     QPainter p( this );
     paintButton( p, button );
 }
 
 void MediaWidget::paintButton( QPainter &p, const Button &button )
 {
     if ( button.isDown )
         p.drawPixmap( upperLeftOfButtonMask, button.pixDown );
     else
         p.drawPixmap( upperLeftOfButtonMask, button.pixUp );
 }
 
 void MediaWidget::setToggleButton( Command command, bool down )
 {
     for ( ButtonVector::iterator it = buttons.begin(); it != buttons.end(); ++it )
         if ( it->command == command ) {
             setToggleButton( *it, down );
             return;
         }
 }
 
 void MediaWidget::setToggleButton( Button &button, bool down )
 {
     if ( down != button.isDown )
         toggleButton( button );
 }
 
 void MediaWidget::toggleButton( Button &button )
 {
     button.isDown = !button.isDown;
 
     paintButton( button );
 }
 
 QPixmap MediaWidget::combineImageWithBackground( const QImage &image, const QPixmap &background, const QPoint &offset )
 {
     QPixmap pix( image.size() );
     QPainter p( &pix );
     p.drawTiledPixmap( pix.rect(), background, offset );
     p.drawImage( 0, 0, image );
     return pix;
 }
 
 QPixmap MediaWidget::addMaskToPixmap( const QPixmap &pix, const QBitmap &mask )
 {
     QPixmap result( pix );
     result.setMask( mask );
     return result;
 }
 
 /* vim: et sw=4 ts=4
  */
diff --git a/noncore/multimedia/opieplayer2/om3u.cpp b/noncore/multimedia/opieplayer2/om3u.cpp
index 69e87e7..26d5e15 100644
--- a/noncore/multimedia/opieplayer2/om3u.cpp
+++ b/noncore/multimedia/opieplayer2/om3u.cpp
@@ -1,163 +1,150 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
-#include "playlistwidget.h"
 #include "om3u.h"
 
-#include <qpe/applnk.h>
-#include <qpe/qpeapplication.h>
-#include <qpe/storage.h>
-#include <qpe/mimetype.h>
-#include <qpe/global.h>
-#include <qpe/resource.h>
-
-#include <qdir.h>
-#include <qregexp.h>
-#include <qstring.h>
-#include <qtextstream.h>
-#include <qstringlist.h>
-#include <qcstring.h>
+
 
 //extern PlayListWidget *playList;
 
 Om3u::Om3u( const QString &filePath, int mode)
       : QStringList (){
 qDebug("<<<<<<<new m3u "+filePath);
   f.setName(filePath);
   f.open(mode);
 }
 
 Om3u::~Om3u(){}
 
 void Om3u::readM3u() {
 //    qDebug("<<<<<<reading m3u "+f.name());
     QTextStream t(&f);
                 t.setEncoding(QTextStream::UnicodeUTF8);
                 QString s;
     while ( !t.atEnd() ) {
         s=t.readLine();
 //                qDebug(s);
         if( s.find( "#", 0, TRUE) == -1 ) {
                 if( s.left(2) == "E:" || s.left(2) == "P:" ) {
                     s = s.right( s.length() -2 );
                     QFileInfo f( s );
                     QString name = f.baseName();
                     name = name.right( name.length() - name.findRev( "\\", -1, TRUE )  -1 );
                     s=s.replace( QRegExp( "\\" ), "/" );
                     append(s);
 //                    qDebug(s);
                 } else { // is url
                     QString name;
                     name = s;
                     append(name);
                 }
         }
     }
 }
 
 void Om3u::readPls() { //it's a pls file
         QTextStream t( &f );
                                 t.setEncoding(QTextStream::UnicodeUTF8);
                                 QString s;
         while ( !t.atEnd() ) {
             s = t.readLine();
             if( s.left(4)  == "File" ) {
                 s = s.right( s.length() - s.find("=",0,true)-1 );
                 s = s.stripWhiteSpace();
                 s.replace( QRegExp( "%20" )," ");
 //                qDebug( "adding " + s + " to playlist" );
                 // numberofentries=2
                 // File1=http
                 // Title
                 // Length
                 // Version
                 // File2=http
                 s = s.replace( QRegExp( "\\" ), "/" );
                 QFileInfo f( s );
                 QString name = f.baseName();
                 if( name.left( 4 ) == "http" ) {
                     name = s.right( s.length() - 7);
                 }  else {
                     name = s;
                 }
                 name = name.right( name.length() - name.findRev( "\\", -1, TRUE) - 1 );
                 if( s.at( s.length() - 4) == '.') // if this is probably a file
                 append(s);
                 else { //if its a url
 //                     if( name.right( 1 ).find( '/' ) == -1) {
 //                         s += "/";
 //                     }
                     append(s);
                 }
             }
         }
 }
 
 void Om3u::write() { //writes list to m3u file
   QString list;
         QTextStream t(&f);
   t.setEncoding(QTextStream::UnicodeUTF8);
  if(count()>0) {
     for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) {
 //      qDebug(*it);
                                 t << *it << "\n";
     }
   }
 //    f.close();
 }
 
 void Om3u::add(const QString &filePath) { //adds to m3u file
     append(filePath);
 }
 
 void Om3u::remove(const QString &filePath) { //removes from m3u list
   QString list, currentFile;
   if(count()>0) {
     for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) {
       currentFile=*it;
       //        qDebug(*it);
 
       if( filePath != currentFile)
         list += currentFile+"\n";
     }
     f.writeBlock( list, list.length() );
   }
 }
 
 void Om3u::deleteFile(const QString &/*filePath*/) {//deletes m3u file
      f.close();
      f.remove();
 
 }
 
 void Om3u::close() { //closes m3u file
     f.close();
 }
diff --git a/noncore/multimedia/opieplayer2/playlistselection.cpp b/noncore/multimedia/opieplayer2/playlistselection.cpp
index 2019b3a..015896f 100644
--- a/noncore/multimedia/opieplayer2/playlistselection.cpp
+++ b/noncore/multimedia/opieplayer2/playlistselection.cpp
@@ -1,214 +1,206 @@
 /**********************************************************************
 ** 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 <qpe/applnk.h>
-#include <qpe/resource.h>
-#include <qpe/config.h>
 
-#include <qpainter.h>
-#include <qimage.h>
 #include <qheader.h>
-#include <qlistview.h>
-#include <qlist.h>
-#include <qpixmap.h>
 
 #include "playlistselection.h"
 
 #include <stdlib.h>
 
 class PlayListSelectionItem : public QListViewItem {
 public:
     PlayListSelectionItem( QListView *parent, const DocLnk *f ) : QListViewItem( parent ), fl( f ) {
   setText( 0, f->name() );
   setPixmap( 0, f->pixmap() );
     }
 
     ~PlayListSelectionItem() {
     };
 
     const DocLnk *file() const { return fl; }
 
 private:
     const DocLnk *fl;
 };
 
 
 PlayListSelection::PlayListSelection( QWidget *parent, const char *name )
     : QListView( parent, name )
 {
 //    qDebug("starting playlistselector");
 // #ifdef USE_PLAYLIST_BACKGROUND
 //    setStaticBackground( TRUE );
 //      setBackgroundPixmap( Resource::loadPixmap( "opieplayer/background" ) );
 
 //      setBackgroundPixmap( Resource::loadPixmap( "launcher/opielogo" ) );
 // #endif
 //      addColumn("Title",236);
 //      setAllColumnsShowFocus( TRUE );
      addColumn( tr( "Playlist Selection" ) );
     header()->hide();
     setSorting( -1, FALSE );
 }
 
 
 PlayListSelection::~PlayListSelection() {
 }
 
 
 // #ifdef USE_PLAYLIST_BACKGROUND
 void PlayListSelection::drawBackground( QPainter *p, const QRect &r ) {
 //  qDebug("drawBackground");
    p->fillRect( r, QBrush( white ) );
 //        QImage logo = Resource::loadImage( "launcher/opielogo" );
 //          if ( !logo.isNull() )
 //        p->drawImage( (width() - logo.width()) / 2, (height() - logo.height()) / 2, logo );
 }
 // #endif
 
 
 void PlayListSelection::contentsMouseMoveEvent( QMouseEvent *event ) {
     if ( event->state() == QMouseEvent::LeftButton ) {
   QListViewItem *currentItem = selectedItem();
   QListViewItem *itemUnder = itemAt( QPoint( event->pos().x(), event->pos().y() - contentsY() ) );
   if ( currentItem && currentItem->itemAbove() == itemUnder )
       moveSelectedUp();
   else if ( currentItem && currentItem->itemBelow() == itemUnder )
       moveSelectedDown();
     }
 }
 
 
 const DocLnk *PlayListSelection::current() {
     PlayListSelectionItem *item = (PlayListSelectionItem *)selectedItem();
     if ( item )
   return item->file();
     return NULL;
 }
 
 
 void PlayListSelection::addToSelection( const DocLnk &lnk ) {
     PlayListSelectionItem *item = new PlayListSelectionItem( this, new DocLnk( lnk ) );
     QListViewItem *current = selectedItem();
     if ( current )
         item->moveItem( current );
     setSelected( item, TRUE );
     ensureItemVisible( selectedItem() );
 }
 
 
 void PlayListSelection::removeSelected() {
     QListViewItem *item = selectedItem();
     delete item;
     setSelected( currentItem(), TRUE );
     ensureItemVisible( selectedItem() );
 }
 
 
 void PlayListSelection::moveSelectedUp() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemAbove() )
   item->itemAbove()->moveItem( item );
     ensureItemVisible( selectedItem() );
 }
 
 
 void PlayListSelection::moveSelectedDown() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemBelow() )
         item->moveItem( item->itemBelow() );
     ensureItemVisible( selectedItem() );
 }
 
 
 bool PlayListSelection::prev() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemAbove() )
         setSelected( item->itemAbove(), TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 bool PlayListSelection::next() {
     QListViewItem *item = selectedItem();
     if ( item && item->itemBelow() )
         setSelected( item->itemBelow(), TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 
 bool PlayListSelection::first() {
     QListViewItem *item = firstChild();
     if ( item )
         setSelected( item, TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 
 bool PlayListSelection::last() {
     QListViewItem *prevItem = NULL;
     QListViewItem *item = firstChild();
     while ( ( item = item->nextSibling() ) )
   prevItem = item;
     if ( prevItem )
         setSelected( prevItem, TRUE );
     else
   return FALSE;
     ensureItemVisible( selectedItem() );
     return TRUE;
 }
 
 void PlayListSelection::unSelect()
 {
     //QListViewItem *item = selectedItem();
     setSelected( currentItem(), FALSE);
 }
 
 void PlayListSelection::writeCurrent( Config& cfg ) {
     cfg.setGroup("PlayList");
     QListViewItem *item = selectedItem();
     if ( item )
         cfg.writeEntry("current", item->text(0) );
     qDebug(item->text(0));
 
 }
 
 void  PlayListSelection::setSelectedItem(const QString &strk ) {
 
     unSelect();
     QListViewItemIterator it( this );
     for ( ; it.current(); ++it ) {
 //        qDebug( it.current()->text(0));
         if( strk == it.current()->text(0)) {
 //             qDebug( "We have a match "+strk);
             setSelected( it.current(), TRUE);
             ensureItemVisible( it.current() );
             return;
         }
     }
 //     setSelected( item, TRUE );
 //     ensureItemVisible( selectedItem() );
 }
diff --git a/noncore/multimedia/opieplayer2/playlistwidget.cpp b/noncore/multimedia/opieplayer2/playlistwidget.cpp
index 0a84268..84aba55 100644
--- a/noncore/multimedia/opieplayer2/playlistwidget.cpp
+++ b/noncore/multimedia/opieplayer2/playlistwidget.cpp
@@ -1,1043 +1,1042 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002,2003 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include <qtoolbar.h>
 
 #include <opie/ofiledialog.h>
 
 #include <qmessagebox.h>
 
 #include "playlistselection.h"
 #include "playlistwidget.h"
 #include "mediaplayer.h"
-#include "mediaplayerstate.h"
 #include "inputDialog.h"
 #include "om3u.h"
 #include "playlistfileview.h"
 
 //only needed for the random play
 #include <assert.h>
 
 PlayListWidget::PlayListWidget(QWidget* parent, const char* name, WFlags fl )
     : PlayListWidgetGui( parent, "playList" ) , currentFileListView( 0 )
 {
     mediaPlayerState = new MediaPlayerState(0, "mediaPlayerState" );
     m_mp = new MediaPlayer(*this, *mediaPlayerState, 0, "mediaPlayer");
 
 
 
     d->tbAddToList =  new ToolButton( bar, tr( "Add to Playlist" ),
                                       "opieplayer2/add_to_playlist",
                                       this , SLOT(addSelected() ) );
     d->tbRemoveFromList = new ToolButton( bar, tr( "Remove from Playlist" ),
                                           "opieplayer2/remove_from_playlist",
                                           this , SLOT(removeSelected() ) );
     d->tbPlay    = new ToolButton( bar, tr( "Play" ), "opieplayer2/play",
                                    this , SLOT( btnPlay(bool) ), TRUE );
     d->tbShuffle = new ToolButton( bar, tr( "Randomize" ),"opieplayer2/shuffle",
                                    mediaPlayerState, SLOT( setShuffled(bool) ), TRUE );
     d->tbLoop    = new ToolButton( bar, tr( "Loop" ), "opieplayer2/loop",
                                    mediaPlayerState, SLOT( setLooping(bool) ), TRUE );
 
     (void)new MenuItem( pmPlayList, tr( "Clear List" ), this, SLOT( clearList() ) );
     (void)new MenuItem( pmPlayList, tr( "Add all audio files" ),
                         this, SLOT( addAllMusicToList() ) );
     (void)new MenuItem( pmPlayList, tr( "Add all video files" ),
                         this, SLOT( addAllVideoToList() ) );
     (void)new MenuItem( pmPlayList, tr( "Add all files" ),
                         this, SLOT( addAllToList() ) );
     pmPlayList->insertSeparator(-1);
     (void)new MenuItem( pmPlayList, tr( "Add File" ),
                         this,SLOT( openFile() ) );
     (void)new MenuItem( pmPlayList, tr("Add URL"),
                         this,SLOT( openURL() ) );
     pmPlayList->insertSeparator(-1);
     (void)new MenuItem( pmPlayList, tr( "Save Playlist" ),
                         this, SLOT(writem3u() ) );
     pmPlayList->insertSeparator(-1);
     (void)new MenuItem( pmPlayList, tr( "Rescan for Audio Files" ),
                         audioView, SLOT( scanFiles() ) );
     (void)new MenuItem( pmPlayList, tr( "Rescan for Video Files" ),
                         videoView, SLOT( scanFiles() ) );
 
     pmView->insertItem(  Resource::loadPixmap("fullscreen") , tr( "Full Screen"),
                          mediaPlayerState, SLOT( toggleFullscreen() ) );
 
     Config cfg( "OpiePlayer" );
     bool b= cfg.readBoolEntry("FullScreen", 0);
     mediaPlayerState->setFullscreen(  b );
     pmView->setItemChecked( -16, b );
 
     (void)new ToolButton( vbox1, tr( "Move Up" ), "opieplayer2/up",
                           d->selectedFiles, SLOT(moveSelectedUp() ) );
     (void)new ToolButton( vbox1, tr( "Remove" ), "opieplayer2/cut",
                           d->selectedFiles, SLOT(removeSelected() ) );
     (void)new ToolButton( vbox1, tr( "Move Down" ), "opieplayer2/down",
                           d->selectedFiles, SLOT(moveSelectedDown() ) );
     QVBox *stretch2 = new QVBox( vbox1 );
 
     connect( tbDeletePlaylist, ( SIGNAL( released() ) ),
              SLOT( deletePlaylist() ) );
     connect( pmView, SIGNAL( activated(int) ),
              this, SLOT( pmViewActivated(int) ) );
     connect( skinsMenu, SIGNAL( activated(int) ) ,
              this, SLOT( skinsMenuActivated(int) ) );
     connect( d->selectedFiles, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ),
              this,SLOT( playlistViewPressed(int,QListViewItem*,const QPoint&,int) ) );
     connect( audioView, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ),
              this,SLOT( viewPressed(int,QListViewItem*,const QPoint&,int) ) );
     connect( audioView, SIGNAL( returnPressed(QListViewItem*) ),
              this,SLOT( playIt(QListViewItem*) ) );
     connect( audioView, SIGNAL( doubleClicked(QListViewItem*) ),
              this, SLOT( addToSelection(QListViewItem*) ) );
     connect( videoView, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ),
              this,SLOT( viewPressed(int,QListViewItem*,const QPoint&,int) ) );
     connect( videoView, SIGNAL( returnPressed(QListViewItem*) ),
              this,SLOT( playIt(QListViewItem*) ) );
     connect( videoView, SIGNAL( doubleClicked(QListViewItem*) ),
              this, SLOT( addToSelection(QListViewItem*) ) );
     connect( playLists, SIGNAL( fileSelected(const DocLnk&) ),
              this, SLOT( loadList(const DocLnk&) ) );
     connect( tabWidget, SIGNAL ( currentChanged(QWidget*) ),
              this, SLOT( tabChanged(QWidget*) ) );
     connect( mediaPlayerState, SIGNAL( playingToggled(bool) ),
              d->tbPlay,  SLOT( setOn(bool) ) );
     connect( mediaPlayerState, SIGNAL( loopingToggled(bool) ),
              d->tbLoop, SLOT( setOn(bool) ) );
     connect( mediaPlayerState, SIGNAL( shuffledToggled(bool) ),
              d->tbShuffle, SLOT( setOn(bool) ) );
     connect( d->selectedFiles, SIGNAL( doubleClicked(QListViewItem*) ),
              this, SLOT( playIt(QListViewItem*) ) );
     connect ( gammaSlider,  SIGNAL( valueChanged(int) ),
               mediaPlayerState,  SLOT( setVideoGamma(int) ) );
 
     connect( this, SIGNAL(skinSelected() ),
              m_mp, SLOT( reloadSkins() ) );
 
     // see which skins are installed
     populateSkinsMenu();
     initializeStates();
 
     channel = new QCopChannel( "QPE/Application/opieplayer2", this );
     connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
         this, SLOT( qcopReceive(const QCString&,const QByteArray&)) );
 
 
     cfg.setGroup("PlayList");
     QString currentPlaylist = cfg.readEntry( "CurrentPlaylist", "default");
     loadList(DocLnk(  currentPlaylist ) );
 
     tabWidget->showPage( playListTab );
 }
 
 
 PlayListWidget::~PlayListWidget() {
     delete d;
     delete m_mp;
 }
 
 
 void PlayListWidget::initializeStates() {
     d->tbPlay->setOn( mediaPlayerState->isPlaying() );
     d->tbLoop->setOn( mediaPlayerState->isLooping() );
     d->tbShuffle->setOn( mediaPlayerState->isShuffled() );
     d->playListFrame->show();
 }
 
 void PlayListWidget::writeDefaultPlaylist() {
 
     Config config( "OpiePlayer" );
     config.setGroup( "PlayList" );
     QString filename=QPEApplication::documentDir() + "/default.m3u";
     QString currentString = config.readEntry( "CurrentPlaylist", filename);
     if( currentString == filename) {
       Om3u *m3uList;
       //    qDebug("<<<<<<<<<<<<<default>>>>>>>>>>>>>>>>>>>");
       if( d->selectedFiles->first() ) {
         m3uList = new Om3u(filename, IO_ReadWrite | IO_Truncate);
         do {
           //        qDebug(d->selectedFiles->current()->file());
           m3uList->add( d->selectedFiles->current()->file() );
         }
         while ( d->selectedFiles->next() );
 
         m3uList->write();
         m3uList->close();
         delete m3uList;
 
       }
     }
 }
 
 void PlayListWidget::addToSelection( const DocLnk& lnk ) {
     d->setDocumentUsed = FALSE;
     if( QFileInfo( lnk.file() ).exists() ||
         lnk.file().left(4) == "http" ) {
         d->selectedFiles->addToSelection( lnk );
     }
 //          writeCurrentM3u();
 }
 
 
 void PlayListWidget::clearList() {
     while ( first() ) {
         d->selectedFiles->removeSelected();
     }
   Config cfg( "OpiePlayer" );
   cfg.setGroup("PlayList");
   cfg.writeEntry("CurrentPlaylist","default");
   setCaption("OpiePlayer");
 }
 
 void PlayListWidget::viewPressed( int mouse, QListViewItem *, const QPoint& , int) {
     switch (mouse) {
     case LeftButton:
         break;
     case RightButton:
     {
         QPopupMenu  m;
         m.insertItem( tr( "Play Selected" ), this, SLOT( playSelected() ));
         m.insertItem( tr( "Add to Playlist" ), this, SLOT( addSelected() ));
         m.exec( QCursor::pos() );
     }
         break;
     }
 }
 
 
 void PlayListWidget::playlistViewPressed( int mouse, QListViewItem *, const QPoint& , int ) {
     switch (mouse) {
     case LeftButton:
         break;
     case RightButton:
     {
         QPopupMenu  m;
         m.insertItem( tr( "Play" ), this, SLOT( playSelected() ));
         m.insertItem( tr( "Remove" ), this, SLOT( removeSelected() ));
         m.exec( QCursor::pos() );
     }
     break;
     }
 }
 
 
 void PlayListWidget::addAllToList() {
 
 
   audioView->populateView();
 
   QListViewItemIterator audioIt( audioView );
   DocLnk lnk;
   QString filename;
   // iterate through all items of the listview
   for ( ; audioIt.current(); ++audioIt ) {
     filename = audioIt.current()->text(3);
     lnk.setName( QFileInfo(filename).baseName() ); //sets name
     lnk.setFile( filename ); //sets file name
     d->selectedFiles->addToSelection(  lnk);
   }
 
   videoView->populateView();
 
   QListViewItemIterator videoIt( videoView );
   for ( ; videoIt.current(); ++videoIt ) {
     filename = videoIt.current()->text(3);
     lnk.setName( QFileInfo(filename).baseName() ); //sets name
     lnk.setFile( filename ); //sets file name
     d->selectedFiles->addToSelection(  lnk);
   }
 
     tabWidget->setCurrentPage(0);
 
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::addAllMusicToList() {
 
   audioView->populateView();
 
   QListViewItemIterator audioIt( audioView );
   DocLnk lnk;
   QString filename;
   // iterate through all items of the listview
   for ( ; audioIt.current(); ++audioIt ) {
     filename = audioIt.current()->text(3);
     lnk.setName( QFileInfo(filename).baseName() ); //sets name
     lnk.setFile( filename ); //sets file name
     d->selectedFiles->addToSelection(  lnk);
   }
 
     tabWidget->setCurrentPage(0);
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::addAllVideoToList() {
 
   videoView->populateView();
 
   QListViewItemIterator videoIt( videoView );
   DocLnk lnk;
   QString filename;
   for ( ; videoIt.current(); ++videoIt ) {
     filename = videoIt.current()->text(3);
     lnk.setName( QFileInfo(filename).baseName() ); //sets name
     lnk.setFile( filename ); //sets file name
     d->selectedFiles->addToSelection(  lnk);
   }
     tabWidget->setCurrentPage(0);
     writeCurrentM3u();
     d->selectedFiles->first();
 }
 
 
 void PlayListWidget::setDocument( const QString& fileref ) {
   //    qDebug( "<<<<<<<<set document>>>>>>>>>> "+fileref );
     fromSetDocument = TRUE;
     QFileInfo fileInfo(fileref);
 
     if ( !fileInfo.exists() ) {
         QMessageBox::warning( this, tr( "Invalid File" ),
                                tr( "There was a problem in getting the file." ) );
         return;
     }
 
     clearList();
     QString extension = fileInfo.extension(false);
 
     if( extension.find( "m3u", 0, false) != -1
        || extension.find( "pls", 0, false) != -1 ) {
         readListFromFile( fileref );
     } else {
         clearList();
         DocLnk lnk;
         lnk.setName( fileInfo.baseName() ); //sets name
         lnk.setFile( fileref ); //sets file name
         addToSelection( lnk );
         writeCurrentM3u();
 
         d->setDocumentUsed = TRUE;
         mediaPlayerState->setPlaying( FALSE );
         mediaPlayerState->setPlaying( TRUE );
     }
 }
 
 
 void PlayListWidget::useSelectedDocument() {
     d->setDocumentUsed = FALSE;
 }
 
 
 const DocLnk *PlayListWidget::current() const { // this is fugly
     assert( currentTab() == CurrentPlayList );
 
     const DocLnk *lnk = d->selectedFiles->current();
     if ( !lnk ) {
         d->selectedFiles->first();
         lnk = d->selectedFiles->current();
     }
     assert( lnk );
     return lnk;
 }
 
 
 bool PlayListWidget::prev() {
     if ( mediaPlayerState->isShuffled() ) {
         const DocLnk *cur = current();
         int j = 1 + (int)(97.0 * rand() / (RAND_MAX + 1.0));
         for ( int i = 0; i < j; i++ ) {
             if ( !d->selectedFiles->next() )
                 d->selectedFiles->first();
         }
         if ( cur == current() )
             if ( !d->selectedFiles->next() ) {
                 d->selectedFiles->first();
             }
         return TRUE;
     } else {
         if ( !d->selectedFiles->prev() ) {
             if ( mediaPlayerState->isLooping() ) {
                 return d->selectedFiles->last();
             } else {
                 return FALSE;
             }
         }
         return TRUE;
     }
 }
 
 
 bool PlayListWidget::next() {
 //qDebug("<<<<<<<<<<<<next()");
     if ( mediaPlayerState->isShuffled() ) {
         return prev();
     } else {
         if ( !d->selectedFiles->next() ) {
             if ( mediaPlayerState->isLooping() ) {
                 return d->selectedFiles->first();
             } else {
                 return FALSE;
             }
         }
         return TRUE;
     }
 }
 
 
 bool PlayListWidget::first() {
     return d->selectedFiles->first();
 }
 
 
 bool PlayListWidget::last() {
     return d->selectedFiles->last();
 }
 
 
  void PlayListWidget::saveList() {
    writem3u();
  }
 
 
 void PlayListWidget::loadList( const DocLnk & lnk) {
     QString name = lnk.name();
 
     if( name.length()>0) {
         setCaption("OpiePlayer: "+name);
         clearList();
         readListFromFile(lnk.file());
         tabWidget->setCurrentPage(0);
     }
 }
 
 void PlayListWidget::addSelected() {
   assert( inFileListMode() );
 
   QListViewItemIterator it( currentFileListView );
   for ( ; it.current(); ++it )
       if ( it.current()->isSelected() ) {
           QString filename = it.current()->text(3);
 
           DocLnk lnk;
           lnk.setName( QFileInfo( filename ).baseName() ); //sets name
           lnk.setFile( filename ); //sets file name
 
           d->selectedFiles->addToSelection( lnk );
       }
 
   currentFileListView->clearSelection();
 
   writeCurrentM3u();
 }
 
 
 void PlayListWidget::removeSelected() {
     d->selectedFiles->removeSelected( );
     writeCurrentM3u();
 }
 
 
 void PlayListWidget::playIt( QListViewItem *it) {
     if(!it) return;
     mediaPlayerState->setPlaying(FALSE);
     mediaPlayerState->setPlaying(TRUE);
     d->selectedFiles->unSelect();
 }
 
 
 void PlayListWidget::addToSelection( QListViewItem *it) {
   d->setDocumentUsed = FALSE;
 
   if(it) {
     if ( currentTab() == CurrentPlayList )
         return;
     DocLnk lnk;
     QString filename;
 
     filename=it->text(3);
     lnk.setName( QFileInfo(filename).baseName() ); //sets name
     lnk.setFile( filename ); //sets file name
     d->selectedFiles->addToSelection(  lnk);
 
     writeCurrentM3u();
 //    tabWidget->setCurrentPage(0);
 
   }
 }
 
 
 void PlayListWidget::tabChanged(QWidget *) {
 
     d->tbPlay->setEnabled( true );
 
     disconnect( audioView, SIGNAL( itemsSelected(bool) ),
                 d->tbPlay, SLOT( setEnabled(bool) ) );
     disconnect( videoView, SIGNAL( itemsSelected(bool) ),
                 d->tbPlay, SLOT( setEnabled(bool) ) );
 
     currentFileListView = 0;
 
     switch ( currentTab() ) {
     case CurrentPlayList:
     {
         if( !tbDeletePlaylist->isHidden() )  {
             tbDeletePlaylist->hide();
         }
         d->tbRemoveFromList->setEnabled(TRUE);
         d->tbAddToList->setEnabled(FALSE);
 
         d->tbPlay->setEnabled( !d->selectedFiles->isEmpty() );
     }
     break;
     case AudioFiles:
     {
         audioView->populateView();
 
         if( !tbDeletePlaylist->isHidden() ) {
             tbDeletePlaylist->hide();
         }
         d->tbRemoveFromList->setEnabled(FALSE);
         d->tbAddToList->setEnabled(TRUE);
 
         connect( audioView, SIGNAL( itemsSelected(bool) ),
                  d->tbPlay, SLOT( setEnabled(bool) ) );
 
         d->tbPlay->setEnabled( audioView->hasSelection() );
 
         currentFileListView = audioView;
     }
     break;
     case VideoFiles:
     {
         videoView->populateView();
         if( !tbDeletePlaylist->isHidden() ) {
             tbDeletePlaylist->hide();
         }
         d->tbRemoveFromList->setEnabled(FALSE);
         d->tbAddToList->setEnabled(TRUE);
 
         connect( videoView, SIGNAL( itemsSelected(bool) ),
                  d->tbPlay, SLOT( setEnabled(bool) ) );
 
         d->tbPlay->setEnabled( videoView->hasSelection() );
 
         currentFileListView = videoView;
     }
     break;
     case PlayLists:
     {
         if( tbDeletePlaylist->isHidden() ) {
             tbDeletePlaylist->show();
         }
         playLists->reread();
         d->tbAddToList->setEnabled(FALSE);
 
         d->tbPlay->setEnabled( false );
     }
     break;
     };
 }
 
 
 void PlayListWidget::btnPlay(bool b) {
 //    mediaPlayerState->setPlaying(false);
     mediaPlayerState->setPlaying(b);
     insanityBool=FALSE;
 }
 
 void PlayListWidget::deletePlaylist() {
   switch( QMessageBox::information( this, (tr("Remove Playlist?")),
                                     (tr("You really want to delete\nthis playlist?")),
                                     (tr("Yes")), (tr("No")), 0 )){
   case 0: // Yes clicked,
     QFile().remove(playLists->selectedDocument().file());
     QFile().remove(playLists->selectedDocument().linkFile());
     playLists->reread();
     break;
   case 1: // Cancel
     break;
   };
 }
 
 
 void PlayListWidget::playSelected() {
     btnPlay( TRUE);
 }
 
 bool PlayListWidget::inFileListMode() const
 {
     TabType tab = currentTab();
     return tab == AudioFiles || tab == VideoFiles;
 }
 
 void PlayListWidget::openURL() {
     // http://66.28.164.33:2080
     // http://somafm.com/star0242.m3u
     QString filename, name;
     InputDialog *fileDlg;
     fileDlg = new InputDialog(this,tr("Add  URL"),TRUE, 0);
     fileDlg->exec();
     if( fileDlg->result() == 1 ) {
         filename = fileDlg->text();
         qDebug( "Selected filename is " + filename );
         //            Om3u *m3uList;
             DocLnk lnk;
             Config cfg( "OpiePlayer" );
             cfg.setGroup("PlayList");
 
         if(filename.left(4) == "http") {
             QString m3uFile, m3uFilePath;
             if(filename.find(":",8,TRUE) != -1) { //found a port
                 m3uFile = filename.left( filename.find( ":",8,TRUE));
                 m3uFile = m3uFile.right(  7);
             } else if(filename.left(4) == "http"){
                 m3uFile=filename;
                 m3uFile = m3uFile.right( m3uFile.length() - 7);
             } else{
                 m3uFile=filename;
             }
 
             lnk.setName( filename ); //sets name
             lnk.setFile( filename ); //sets file name
 
 //            lnk.setIcon("opieplayer2/musicfile");
 
             d->selectedFiles->addToSelection(  lnk );
             writeCurrentM3u();
             d->selectedFiles->setSelectedItem( lnk.name());
         }
         else if( filename.right( 3) == "m3u" ||  filename.right(3) == "pls" ) {
             readListFromFile( filename );
         } else {
             lnk.setName( QFileInfo(filename).baseName() ); //sets name
             lnk.setFile( filename ); //sets file name
             d->selectedFiles->addToSelection(  lnk);
             writeCurrentM3u();
             d->selectedFiles->setSelectedItem( lnk.name());
         }
     }
 
 
     delete fileDlg;
 }
 
 
 void PlayListWidget::openFile() {
 
     QString filename, name;
 
     Config cfg( "OpiePlayer" );
     cfg.setGroup("Dialog");
     MimeTypes types;
     QStringList audio, video, all;
     audio << "audio/*";
     audio << "playlist/plain";
     audio << "application/ogg";
     audio << "audio/x-mpegurl";
 
     video << "video/*";
     video << "playlist/plain";
 
     all += audio;
     all += video;
     types.insert("All Media Files", all );
     types.insert("Audio",  audio );
     types.insert("Video", video );
 
     QString str = OFileDialog::getOpenFileName( 1,
                                                 cfg.readEntry("LastDirectory",QPEApplication::documentDir()),"",
                                                 types, 0 );
 
     if(str.left(2) == "//")  {
         str=str.right(str.length()-1);
     }
     cfg.writeEntry( "LastDirectory" ,QFileInfo( str ).dirPath() );
 
     if( !str.isEmpty() ) {
 
         qDebug( "Selected filename is " + str );
         filename = str;
         DocLnk lnk;
 
         if( filename.right( 3) == "m3u" ||  filename.right(3) == "pls" ) {
             readListFromFile( filename );
         } else {
             lnk.setName( QFileInfo(filename).baseName() ); //sets name
             lnk.setFile( filename ); //sets file name
             d->selectedFiles->addToSelection(  lnk );
             writeCurrentM3u();
             d->selectedFiles->setSelectedItem( lnk.name() );
         }
     }
 }
 
 
 void PlayListWidget::readListFromFile( const QString &filename ) {
     qDebug( "read list filename " + filename );
     QFileInfo fi(filename);
     Om3u *m3uList;
     QString s, name;
     m3uList = new Om3u( filename, IO_ReadOnly );
     if(fi.extension(false).find("m3u",0,false) != -1 )
         m3uList->readM3u();
     else if(fi.extension(false).find("pls",0,false) != -1 )
         m3uList->readPls();
 
     DocLnk lnk;
     for ( QStringList::ConstIterator it = m3uList->begin(); it != m3uList->end(); ++it ) {
         s = *it;
         //        qDebug(s);
         if(s.left(4)=="http") {
           lnk.setName( s ); //sets file name
           lnk.setIcon("opieplayer2/musicfile");
           lnk.setFile( s ); //sets file name
 
         }  else { //is file
           lnk.setName( QFileInfo(s).baseName());
           if(s.left(1) != "/")  {
 
             lnk.setFile( QFileInfo(filename).dirPath()+"/"+s);
           } else {
             lnk.setFile( s);
           }
         }
         d->selectedFiles->addToSelection( lnk );
     }
     Config config( "OpiePlayer" );
     config.setGroup( "PlayList" );
 
     config.writeEntry("CurrentPlaylist",filename);
     config.write();
     currentPlayList=filename;
 
     m3uList->close();
     delete m3uList;
 
     d->selectedFiles->setSelectedItem( s);
     setCaption(tr("OpiePlayer: ")+ QFileInfo(filename).baseName());
 
 }
 
 //  writes current playlist to current m3u file */
  void PlayListWidget::writeCurrentM3u() {
    qDebug("writing to current m3u");
    Config cfg( "OpiePlayer" );
    cfg.setGroup("PlayList");
    QString currentPlaylist = cfg.readEntry("CurrentPlaylist","default");
 
    Om3u *m3uList;
    m3uList = new Om3u( currentPlaylist, IO_ReadWrite | IO_Truncate );
    if( d->selectedFiles->first()) {
 
        do {
            //      qDebug( "add writeCurrentM3u " +d->selectedFiles->current()->file());
            m3uList->add( d->selectedFiles->current()->file() );
        }
        while ( d->selectedFiles->next() );
        //    qDebug( "<<<<<<<<<<<<>>>>>>>>>>>>>>>>>" );
        m3uList->write();
       m3uList->close();
    }
    delete m3uList;
 
  }
 
   /*
  writes current playlist to m3u file */
 void PlayListWidget::writem3u() {
     //InputDilog *fileDlg;
     //fileDlg = new InputDialog( this, tr( "Save m3u Playlist " ), TRUE, 0);
     //fileDlg->exec();
 
     Config cfg( "OpiePlayer" );
     cfg.setGroup("Dialog");
     MimeTypes types;
     QStringList audio, video, all;
     audio << "audio/*";
     audio << "playlist/plain";
     audio << "audio/x-mpegurl";
 
     video << "video/*";
     video << "playlist/plain";
 
     all += audio;
     all += video;
     types.insert("All Media Files", all );
     types.insert("Audio",  audio );
     types.insert("Video", video );
 
     QString str = OFileDialog::getOpenFileName( 1,
                   cfg.readEntry("LastDirectory",QPEApplication::documentDir()),"",
                   types, 0 );
     if(str.left(2) == "//") str=str.right(str.length()-1);
     cfg.writeEntry("LastDirectory" ,QFileInfo(str).dirPath());
 
 
     QString name, filename, list;
     Om3u *m3uList;
 
     if( !str.isEmpty() ) {
         name = str;
         //       name = fileDlg->text();
 //        qDebug( filename );
         if( name.find("/",0,true) != -1) {// assume they specify a file path
             filename = name;
             name = name.right(name.length()- name.findRev("/",-1,true) - 1 );
         }
         else //otherwise dump it somewhere noticable
             filename = QPEApplication::documentDir() + "/" + name;
 
         if( filename.right( 3 ) != "m3u" ) //needs filename extension
             filename += ".m3u";
 
         if( d->selectedFiles->first()) { //ramble through playlist view
             m3uList = new Om3u( filename, IO_ReadWrite | IO_Truncate);
 
             do {
             m3uList->add( d->selectedFiles->current()->file());
           }
           while ( d->selectedFiles->next() );
           //    qDebug( list );
           m3uList->write();
           m3uList->close();
           delete m3uList;
 
           //delete fileDlg;
 
           DocLnk lnk;
           lnk.setFile( filename);
           lnk.setIcon("opieplayer2/playlist2");
           lnk.setName( name); //sets file name
 
           // qDebug(filename);
           Config config( "OpiePlayer" );
           config.setGroup( "PlayList" );
 
           config.writeEntry("CurrentPlaylist",filename);
           currentPlayList=filename;
 
           if(!lnk.writeLink()) {
             qDebug("Writing doclink did not work");
           }
 
           setCaption(tr("OpiePlayer: ") + name);
         }
     }
 }
 
 void PlayListWidget::keyReleaseEvent( QKeyEvent *e ) {
   switch ( e->key() ) {
     ////////////////////////////// Zaurus keys
   case Key_F9: //activity
     //           if(audioUI->isHidden())
     //             audioUI->showMaximized();
     break;
   case Key_F10: //contacts
     //           if( videoUI->isHidden())
     //             videoUI->showMaximized();
     break;
   case Key_F11: //menu
     break;
   case Key_F12: //home
     //          doBlank();
     break;
   case Key_F13: //mail
     //           doUnblank();
     break;
   case Key_Q: //add to playlist
     addSelected();
     break;
   case Key_R: //remove from playlist
     removeSelected();
     break;
     //       case Key_P: //play
     //           qDebug("Play");
     //           playSelected();
     //           break;
   case Key_Space:
     //          playSelected(); puh
     break;
   case Key_1:
     tabWidget->setCurrentPage( 0 );
     break;
   case Key_2:
     tabWidget->setCurrentPage( 1 );
     break;
   case Key_3:
     tabWidget->setCurrentPage( 2 );
     break;
   case Key_4:
     tabWidget->setCurrentPage( 3 );
     break;
   case Key_Down:
     if ( !d->selectedFiles->next() )
       d->selectedFiles->first();
     break;
   case Key_Up:
     if ( !d->selectedFiles->prev() )
       //        d->selectedFiles->last();
       break;
   }
 }
 
 void PlayListWidget::pmViewActivated(int index) {
 //  qDebug("%d", index);
     switch(index) {
     case -16:
     {
         mediaPlayerState->toggleFullscreen();
         bool b=mediaPlayerState->isFullscreen();
         pmView->setItemChecked( index, b);
         Config cfg( "OpiePlayer" );
         cfg.writeEntry( "FullScreen", b );
     }
     break;
     };
 }
 
 void PlayListWidget::populateSkinsMenu() {
     int item = 0;
     defaultSkinIndex = 0;
     QString skinName;
     Config cfg( "OpiePlayer" );
     cfg.setGroup("Options" );
     QString skin = cfg.readEntry( "Skin", "default" );
 
     QDir skinsDir( QPEApplication::qpeDir() + "/pics/opieplayer2/skins" );
     skinsDir.setFilter( QDir::Dirs );
     skinsDir.setSorting(QDir::Name );
     const QFileInfoList *skinslist = skinsDir.entryInfoList();
     QFileInfoListIterator it( *skinslist );
     QFileInfo *fi;
     while ( ( fi = it.current() ) ) {
         skinName =  fi->fileName();
 //        qDebug(  fi->fileName() );
         if( skinName != "." &&  skinName != ".." && skinName !="CVS" )  {
             item = skinsMenu->insertItem( fi->fileName() ) ;
         }
         if( skinName == "default" ) {
             defaultSkinIndex = item;
         }
         if( skinName == skin ) {
             skinsMenu->setItemChecked( item, TRUE );
         }
         ++it;
     }
 }
 
 void PlayListWidget::skinsMenuActivated( int item ) {
     for(unsigned int i = defaultSkinIndex; i > defaultSkinIndex - skinsMenu->count(); i-- ) {
         skinsMenu->setItemChecked( i, FALSE );
     }
     skinsMenu->setItemChecked( item, TRUE );
 
     {
         Config cfg( "OpiePlayer" );
         cfg.setGroup("Options");
         cfg.writeEntry("Skin", skinsMenu->text( item ) );
     }
 
     emit skinSelected();
 }
 
 PlayListWidget::TabType PlayListWidget::currentTab() const
 {
     static const TabType indexToTabType[ TabTypeCount ] =
     { CurrentPlayList, AudioFiles, VideoFiles, PlayLists };
 
     int index = tabWidget->currentPageIndex();
     assert( index < TabTypeCount && index >= 0 );
 
     return indexToTabType[ index ];
 }
 
 PlayListWidget::Entry PlayListWidget::currentEntry() const
 {
     if ( currentTab() == CurrentPlayList ) {
         const DocLnk *lnk = current();
         return Entry( lnk->name(), lnk->file() );
     }
 
     return Entry( currentFileListPathName() );
 }
 
 QString PlayListWidget::currentFileListPathName() const {
     return currentFileListView->currentItem()->text( 3 );
 }
 
 
 void PlayListWidget::qcopReceive(const QCString &msg, const QByteArray &data) {
    qDebug("qcop message "+msg );
    QDataStream stream ( data, IO_ReadOnly );
    if ( msg == "play()" ) { //plays current selection
       btnPlay( true);
    } else if ( msg == "stop()" ) {
       mediaPlayerState->setPlaying( false);
    } else if ( msg == "togglePause()" ) {
       mediaPlayerState->togglePaused();
    } else if ( msg == "next()" ) { //select next in list
       mediaPlayerState->setNext();
    } else if ( msg == "prev()" ) { //select previous in list
       mediaPlayerState->setPrev();
    } else if ( msg == "toggleLooping()" ) { //loop or not loop
       mediaPlayerState->toggleLooping();
    } else if ( msg == "toggleShuffled()" ) { //shuffled or not shuffled
       mediaPlayerState->toggleShuffled();
    } else if ( msg == "volUp()" ) { //volume more
 //       emit moreClicked();
 //       emit moreReleased();
    } else if ( msg == "volDown()" ) { //volume less
 //       emit lessClicked();
 //       emit lessReleased();
    } else if ( msg == "play(QString)" ) { //play this now
       QString file;
       stream >> file;
       setDocument( (const QString &) file);
    } else if ( msg == "add(QString)" ) { //add to playlist
       QString file;
       stream >> file;
       QFileInfo fileInfo(file);
       DocLnk lnk;
       lnk.setName( fileInfo.baseName() ); //sets name
       lnk.setFile( file ); //sets file name
       addToSelection( lnk );
    } else if ( msg == "rem(QString)" ) { //remove from playlist
       QString file;
       stream >> file;
 
    }
 
 }
diff --git a/noncore/multimedia/opieplayer2/playlistwidgetgui.cpp b/noncore/multimedia/opieplayer2/playlistwidgetgui.cpp
index 33fe188..2ff190d 100644
--- a/noncore/multimedia/opieplayer2/playlistwidgetgui.cpp
+++ b/noncore/multimedia/opieplayer2/playlistwidgetgui.cpp
@@ -1,194 +1,193 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include <qtoolbar.h>
 #include <qpe/qpeapplication.h>
 
 #include <qlayout.h>
 #include <qmenubar.h>
 
 #include "playlistselection.h"
 #include "playlistwidget.h"
 #include "mediaplayerstate.h"
 #include "inputDialog.h"
 #include "playlistfileview.h"
 
-#include "mediaplayerstate.h"
 
 PlayListWidgetGui::PlayListWidgetGui(QWidget* parent, const char* name )
     : QMainWindow( parent, name )  {
 
     d = new PlayListWidgetPrivate;
     d->setDocumentUsed = FALSE;
 
     setBackgroundMode( PaletteButton );
     setToolBarsMovable( FALSE );
 
     // Create Toolbar
     QToolBar *toolbar = new QToolBar( this );
     toolbar->setHorizontalStretchable( TRUE );
 
     // Create Menubar
     QMenuBar *menu = new QMenuBar( toolbar );
     menu->setMargin( 0 );
 
     bar = new QToolBar( this );
     bar->setLabel( tr( "Play Operations" ) );
 
     tbDeletePlaylist = new QPushButton( Resource::loadIconSet( "trash" ), "", bar, "close" );
     tbDeletePlaylist->setFlat( TRUE );
     tbDeletePlaylist->setFixedSize( 20, 20 );
 
     tbDeletePlaylist->hide();
 
     pmPlayList = new QPopupMenu( this );
     menu->insertItem( tr( "File" ), pmPlayList );
 
     pmView = new QPopupMenu( this );
     menu->insertItem( tr( "View" ), pmView );
     pmView->isCheckable();
 
     skinsMenu = new QPopupMenu( this );
     pmView->insertItem( tr( "Skins" ), skinsMenu );
     skinsMenu->isCheckable();
 
     gammaMenu = new QPopupMenu( this );
     pmView->insertItem( tr( "Gamma (Video)" ),  gammaMenu );
 
     gammaSlider = new QSlider( QSlider::Vertical,  gammaMenu );
     gammaSlider->setRange( -40, 40 );
     gammaSlider->setTickmarks( QSlider::Left );
     gammaSlider->setTickInterval( 20 );
     gammaSlider->setFocusPolicy( QWidget::StrongFocus );
     gammaSlider->setValue( 0 );
     gammaSlider->setMinimumHeight( 50 );
 
     gammaLCD = new QLCDNumber( 3,  gammaMenu );
     gammaLCD-> setFrameShape ( QFrame::NoFrame );
     gammaLCD-> setSegmentStyle ( QLCDNumber::Flat );
 
     gammaMenu->insertItem( gammaSlider );
     gammaMenu->insertItem( gammaLCD );
 
     connect( gammaSlider, SIGNAL( valueChanged(int) ), gammaLCD, SLOT( display(int) ) );
 
     vbox5 = new QVBox( this );
     QVBox *vbox4 = new QVBox( vbox5 );
     QHBox *hbox6 = new QHBox( vbox4 );
 
     tabWidget = new QTabWidget( hbox6, "tabWidget" );
 
     playListTab = new QWidget( tabWidget, "PlayListTab" );
     tabWidget->insertTab( playListTab, "Playlist");
 
     QGridLayout *Playout = new QGridLayout( playListTab );
     Playout->setSpacing( 2);
     Playout->setMargin( 2);
 
     // Add the playlist area
     QVBox *vbox3 = new QVBox( playListTab );
     d->playListFrame = vbox3;
 
     QHBox *hbox2 = new QHBox( vbox3 );
     d->selectedFiles = new PlayListSelection( hbox2 );
 
     vbox1 = new QVBox( hbox2 );
     QPEApplication::setStylusOperation( d->selectedFiles->viewport(), QPEApplication::RightOnHold );
     QVBox *stretch1 = new QVBox( vbox1 ); // add stretch
 
     Playout->addMultiCellWidget( vbox3, 0, 0, 0, 1 );
 
     QWidget *aTab;
     aTab = new QWidget( tabWidget, "aTab" );
 
     QGridLayout *Alayout = new QGridLayout( aTab );
     Alayout->setSpacing( 2 );
     Alayout->setMargin( 2 );
     // no m3u's here please
     audioView = new PlayListFileView( "audio/mpeg;audio/x-wav;application/ogg", "opieplayer2/musicfile", aTab, "Audioview" );
     Alayout->addMultiCellWidget( audioView, 0, 0, 0, 1 );
     tabWidget->insertTab( aTab, tr( "Audio" ) );
 
     QPEApplication::setStylusOperation( audioView->viewport(), QPEApplication::RightOnHold );
 
     QWidget *vTab;
     vTab = new QWidget( tabWidget, "vTab" );
 
     QGridLayout *Vlayout = new QGridLayout( vTab );
     Vlayout->setSpacing( 2 );
     Vlayout->setMargin( 2 );
     videoView = new PlayListFileView( "video/*", "opieplayer2/videofile", vTab, "Videoview" );
     Vlayout->addMultiCellWidget( videoView, 0, 0, 0, 1 );
 
     QPEApplication::setStylusOperation( videoView->viewport(), QPEApplication::RightOnHold );
 
     tabWidget->insertTab( vTab, tr( "Video" ) );
 
     //playlists list
     QWidget *LTab;
     LTab = new QWidget( tabWidget, "LTab" );
     QGridLayout *Llayout = new QGridLayout( LTab );
     Llayout->setSpacing( 2 );
     Llayout->setMargin( 2 );
 
     playLists = new FileSelector( "playlist/plain;audio/x-mpegurl", LTab, "fileselector" , FALSE, FALSE );
     Llayout->addMultiCellWidget( playLists, 0, 0, 0, 1 );
 
     tabWidget->insertTab( LTab, tr( "Lists" ) );
 
     setCentralWidget( vbox5 );
 }
 
 
 
 PlayListWidgetGui::~PlayListWidgetGui()  {
 }
 
 void PlayListWidgetGui::setView( char view )  {
     if ( view == 'l' )
         showMaximized();
     else
         hide();
 }
 
 
 void PlayListWidgetGui::setActiveWindow()  {
     //  qDebug("SETTING active window");
     // When we get raised we need to ensure that it switches views
     MediaPlayerState::DisplayType origDisplayType = mediaPlayerState->displayType();
     mediaPlayerState->setDisplayType( MediaPlayerState::MediaSelection ); // invalidate
     mediaPlayerState->setDisplayType( origDisplayType ); // now switch back
 }
 
 
diff --git a/noncore/multimedia/opieplayer2/skin.cpp b/noncore/multimedia/opieplayer2/skin.cpp
index 742e495..7c38983 100644
--- a/noncore/multimedia/opieplayer2/skin.cpp
+++ b/noncore/multimedia/opieplayer2/skin.cpp
@@ -1,324 +1,322 @@
 /*
    Copyright (C) 2002 Simon Hausmann <simon@lst.de>
              (C) 2002 Max Reiss <harlekin@handhelds.org>
              (C) 2002 L. Potter <ljp@llornkcor.com>
              (C) 2002 Holger Freyther <zecke@handhelds.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 
 #include "skin.h"
 #include "singleton.h"
 
 #include <qcache.h>
-#include <qmap.h>
 #include <qtimer.h>
 
-#include <qpe/resource.h>
 #include <qpe/config.h>
 
 #include <assert.h>
 
 struct SkinData
 {
     typedef QMap<QString, QImage> ButtonMaskImageMap;
 
     QPixmap backgroundPixmap;
     QImage buttonUpImage;
     QImage buttonDownImage;
     QImage buttonMask;
     ButtonMaskImageMap buttonMasks;
 };
 
 class SkinCache : public Singleton<SkinCache>
 {
 public:
     SkinCache();
 
     SkinData *lookupAndTake( const QString &skinPath, const QString &fileNameInfix );
 
     void store( const QString &skinPath, const QString &fileNameInfix, SkinData *data );
 
 private:
     typedef QCache<SkinData> DataCache;
     typedef QCache<QPixmap> BackgroundPixmapCache;
 
     template <class CacheType>
     void store( const QCache<CacheType> &cache, const QString &key, CacheType *data );
 
     DataCache m_cache;
     BackgroundPixmapCache m_backgroundPixmapCache;
 };
 
 Skin::Skin( const QString &name, const QString &fileNameInfix )
     : m_fileNameInfix( fileNameInfix )
 {
     init( name );
 }
 
 Skin::Skin( const QString &fileNameInfix )
     : m_fileNameInfix( fileNameInfix )
 {
     init( defaultSkinName() );
 }
 
 Skin::~Skin()
 {
     if ( m_isCachable )
         SkinCache::self().store( m_skinPath, m_fileNameInfix, d );
     else
         delete d;
 }
 
 void Skin::init( const QString &name )
 {
     m_isCachable = true;
     m_skinPath = "opieplayer2/skins/" + name;
     d = SkinCache::self().lookupAndTake( m_skinPath, m_fileNameInfix );
 }
 
 QPixmap Skin::backgroundPixmap() const
 {
     if ( d->backgroundPixmap.isNull() )
         d->backgroundPixmap = loadImage( QString( "%1/background" ).arg( m_skinPath ) );
     return d->backgroundPixmap;
 }
 
 QImage Skin::buttonUpImage() const
 {
     if ( d->buttonUpImage.isNull() )
         d->buttonUpImage = loadImage( QString( "%1/skin%2_up" ).arg( m_skinPath ).arg( m_fileNameInfix ) );
     return d->buttonUpImage;
 }
 
 QImage Skin::buttonDownImage() const
 {
     if ( d->buttonDownImage.isNull() )
         d->buttonDownImage = loadImage( QString( "%1/skin%2_down" ).arg( m_skinPath ).arg( m_fileNameInfix ) );
     return d->buttonDownImage;
 }
 
 QImage Skin::buttonMask( const MediaWidget::SkinButtonInfo *skinButtonInfo, uint buttonCount ) const
 {
     if ( !d->buttonMask.isNull() )
         return d->buttonMask;
 
     QSize buttonAreaSize = buttonUpImage().size();
 
     d->buttonMask = QImage( buttonAreaSize, 8, 255 );
     d->buttonMask.fill( 0 );
 
     for ( uint i = 0; i < buttonCount; ++i )
         addButtonToMask( skinButtonInfo[ i ].command + 1, buttonMaskImage( skinButtonInfo[ i ].fileName ) );
 
     return d->buttonMask;
 }
 
 void Skin::addButtonToMask( int tag, const QImage &maskImage ) const
 {
     if ( maskImage.isNull() )
         return;
 
     uchar **dest = d->buttonMask.jumpTable();
     for ( int y = 0; y < d->buttonMask.height(); y++ ) {
         uchar *line = dest[y];
         for ( int x = 0; x < d->buttonMask.width(); x++ )
             if ( !qRed( maskImage.pixel( x, y ) ) )
                 line[x] = tag;
     }
 }
 
 QImage Skin::buttonMaskImage( const QString &fileName ) const
 {
     SkinData::ButtonMaskImageMap::Iterator it = d->buttonMasks.find( fileName );
     if ( it == d->buttonMasks.end() ) {
         QString prefix = m_skinPath + QString::fromLatin1( "/skin%1_mask_" ).arg( m_fileNameInfix );
         QString path = prefix + fileName;
         it = d->buttonMasks.insert( fileName, loadImage( path ) );
     }
     return *it;
 }
 
 QString Skin::defaultSkinName()
 {
     Config cfg( "OpiePlayer" );
     cfg.setGroup( "Options" );
     return cfg.readEntry( "Skin", "default" );
 }
 
 QImage Skin::loadImage( const QString &fileName )
 {
     return QImage( Resource::findPixmap( fileName ) );
 }
 
 SkinCache::SkinCache()
 {
     // let's say we cache two skins (audio+video) at maximum
     m_cache.setMaxCost( 2 );
     // ... and one background pixmap
     m_backgroundPixmapCache.setMaxCost( 1 );
 }
 
 SkinData *SkinCache::lookupAndTake( const QString &skinPath, const QString &fileNameInfix )
 {
     QString key = skinPath + fileNameInfix;
 
     SkinData *data = m_cache.take( key );
     if ( !data )
         data = new SkinData;
     else
         qDebug( "SkinCache: hit" );
 
     QPixmap *bgPixmap = m_backgroundPixmapCache.find( skinPath );
     if ( bgPixmap ) {
         qDebug( "SkinCache: hit on bgpixmap" );
         data->backgroundPixmap = *bgPixmap;
     }
     else
         data->backgroundPixmap = QPixmap();
 
     return data;
 }
 
 void SkinCache::store( const QString &skinPath, const QString &fileNameInfix, SkinData *data )
 {
     QPixmap *backgroundPixmap = new QPixmap( data->backgroundPixmap );
 
     data->backgroundPixmap = QPixmap();
 
     QString key = skinPath + fileNameInfix;
 
     if ( m_cache.find( key, false /*ref*/ ) != 0 ||
          !m_cache.insert( key, data ) )
         delete data;
 
     if ( m_backgroundPixmapCache.find( skinPath, false /*ref*/ ) != 0 ||
          !m_backgroundPixmapCache.insert( skinPath, backgroundPixmap ) )
         delete backgroundPixmap;
 }
 
 SkinLoader::IncrementalLoader::IncrementalLoader( const Info &info )
     : m_skin( info.skinName, info.fileNameInfix ), m_info( info )
 {
     m_currentState = LoadBackgroundPixmap;
 }
 
 SkinLoader::IncrementalLoader::LoaderResult SkinLoader::IncrementalLoader::loadStep()
 {
     switch ( m_currentState ) {
         case LoadBackgroundPixmap:
             qDebug( "load bgpixmap" );
             m_skin.backgroundPixmap();
             m_currentState = LoadButtonUpImage;
             break;
         case LoadButtonUpImage:
             qDebug( "load upimage" );
             m_skin.buttonUpImage();
             m_currentState = LoadButtonDownImage;
             break;
         case LoadButtonDownImage:
             qDebug( "load downimage" );
             m_skin.buttonDownImage();
             m_currentState = LoadButtonMasks;
             m_currentButton = 0;
             break;
         case LoadButtonMasks:
             qDebug( "load button masks %i", m_currentButton );
             m_skin.buttonMaskImage( m_info.buttonInfo[ m_currentButton ].fileName );
 
             m_currentButton++;
             if ( m_currentButton >= m_info.buttonCount )
                 m_currentState = LoadButtonMask;
 
             break;
         case LoadButtonMask:
             qDebug( "load whole mask" );
             m_skin.buttonMask( m_info.buttonInfo, m_info.buttonCount );
             return LoadingCompleted;
     }
 
     return MoreToCome;
 }
 
 SkinLoader::SkinLoader()
     : m_currentLoader( 0 ), m_timerId( -1 )
 {
 }
 
 SkinLoader::~SkinLoader()
 {
     qDebug( "SkinLoader::~SkinLoader()" );
     killTimers();
     delete m_currentLoader;
 }
 
 void SkinLoader::schedule( const MediaWidget::GUIInfo &guiInfo )
 {
     schedule( Skin::defaultSkinName(), guiInfo );
 }
 
 void SkinLoader::schedule( const QString &skinName, const MediaWidget::GUIInfo &guiInfo )
 {
     pendingSkins << Info( skinName, guiInfo );
 }
 
 void SkinLoader::start()
 {
     assert( m_timerId == -1 );
     m_timerId = startTimer( 100 /* ms */ );
     qDebug( "SkinLoader::start() %d jobs", pendingSkins.count() );
 }
 
 void SkinLoader::timerEvent( QTimerEvent *ev )
 {
     if ( ev->timerId() != m_timerId ) {
         QObject::timerEvent( ev );
         return;
     }
 
     if ( !m_currentLoader ) {
 
         if ( pendingSkins.isEmpty() ) {
             qDebug( "all jobs done" );
             killTimer( m_timerId );
             m_timerId = -1;
             // ### qt3: use deleteLater();
             QTimer::singleShot( 0, this, SLOT( deleteMe() ) );
             return;
         }
 
         Info nfo = *pendingSkins.begin();
         pendingSkins.remove( pendingSkins.begin() );
 
         m_currentLoader = new IncrementalLoader( nfo );
         qDebug( "new loader %i jobs left", pendingSkins.count() );
     }
 
     if ( m_currentLoader->loadStep() == IncrementalLoader::LoadingCompleted ) {
         delete m_currentLoader;
         m_currentLoader = 0;
     }
 
     qDebug( "finished step" );
 }
 
 void SkinLoader::deleteMe()
 {
     delete this;
 }
 
 /* vim: et sw=4 ts=4
  */
diff --git a/noncore/multimedia/opieplayer2/videowidget.cpp b/noncore/multimedia/opieplayer2/videowidget.cpp
index a4d09f5..0625376 100644
--- a/noncore/multimedia/opieplayer2/videowidget.cpp
+++ b/noncore/multimedia/opieplayer2/videowidget.cpp
@@ -1,303 +1,301 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include "videowidget.h"
-#include "mediaplayerstate.h"
-#include "playlistwidget.h"
 
 
 #ifdef Q_WS_QWS
 # define USE_DIRECT_PAINTER
 # include <qdirectpainter_qws.h>
 # include <qgfxraster_qws.h>
 #endif
 
 
 namespace
 {
 
 const int xo = 2; // movable x offset
 const int yo = 0; // movable y offset
 
 const MediaWidget::SkinButtonInfo skinInfo[] =
 {
     { MediaWidget::Play, "play", MediaWidget::ToggleButton },
     { MediaWidget::Stop, "stop", MediaWidget::NormalButton },
     { MediaWidget::Next, "fwd", MediaWidget::NormalButton },
     { MediaWidget::Previous, "back", MediaWidget::NormalButton },
     { MediaWidget::VolumeUp, "up", MediaWidget::NormalButton },
     { MediaWidget::VolumeDown, "down", MediaWidget::NormalButton },
     { MediaWidget::FullScreen, "full", MediaWidget::ToggleButton }
 };
 
 const uint buttonCount = sizeof( skinInfo ) / sizeof( skinInfo[ 0 ] );
 
 }
 
 VideoWidget::VideoWidget( PlayListWidget &playList, MediaPlayerState &mediaPlayerState, QWidget* parent, const char* name )
     : MediaWidget( playList, mediaPlayerState, parent, name ), scaledWidth( 0 ), scaledHeight( 0 ), videoSliderBeingMoved( false )
 {
     setCaption( tr("OpiePlayer - Video") );
 
     videoFrame = new XineVideoWidget ( this, "Video frame" );
 
     connect ( videoFrame, SIGNAL( videoResized(const QSize&)), this, SIGNAL( videoResized(const QSize&)));
     connect ( videoFrame,  SIGNAL( clicked() ),  this,  SLOT ( backToNormal() ) );
 
     slider = 0;
 
     loadSkin();
 
     setLength( mediaPlayerState.length() );
     setPosition( mediaPlayerState.position() );
     setFullscreen( mediaPlayerState.isFullscreen() );
     setPlaying( mediaPlayerState.isPlaying() );
 }
 
 
 VideoWidget::~VideoWidget()
 {
 }
 
 MediaWidget::GUIInfo VideoWidget::guiInfo()
 {
     return GUIInfo( "V" /* infix */, ::skinInfo, ::buttonCount );
 }
 
 void VideoWidget::resizeEvent( QResizeEvent *e ) {
     int h = height();
     int w = width();
     //int Vh = 160;
     //int Vw = 220;
 
     slider->setFixedWidth( w - 20 );
     slider->setGeometry( QRect( 15, h - 22, w - 90, 20 ) );
     slider->setBackgroundOrigin( QWidget::ParentOrigin );
     slider->setFocusPolicy( QWidget::NoFocus );
     slider->setBackgroundPixmap( backgroundPixmap );
 
     upperLeftOfButtonMask.rx() = 0;// ( imgUp->width() ) / 2;
     if(w>h)
         upperLeftOfButtonMask.ry() = 0;
     else
         upperLeftOfButtonMask.ry() = 185;//(( Vh  - imgUp->height() ) / 2) - 10;
 
     MediaWidget::resizeEvent( e );
 }
 
 void VideoWidget::sliderPressed() {
     videoSliderBeingMoved = TRUE;
 }
 
 void VideoWidget::sliderReleased() {
     videoSliderBeingMoved = FALSE;
     if ( slider->width() == 0 ) {
         return;
     }
     long val = long((double)slider->value() * mediaPlayerState.length() / slider->width());
     mediaPlayerState.setPosition( val );
 }
 
 void VideoWidget::setPosition( long i ) {
     updateSlider( i, mediaPlayerState.length() );
 }
 
 
 void VideoWidget::setLength( long max ) {
     updateSlider( mediaPlayerState.position(), max );
 }
 
 void VideoWidget::setDisplayType( MediaPlayerState::DisplayType displayType )
 {
     if ( displayType == MediaPlayerState::Video ) {
         makeVisible();
         return;
     }
 
     // Effectively blank the view next time we show it so it looks nicer
     scaledWidth = 0;
     scaledHeight = 0;
     hide();
 }
 
 void VideoWidget::loadSkin()
 {
     loadDefaultSkin( guiInfo() );
 
     delete slider;
     slider = new QSlider( Qt::Horizontal, this );
     slider->setMinValue( 0 );
     slider->setMaxValue( 1 );
     slider->setBackgroundPixmap( backgroundPixmap );
     //slider->setFocusPolicy( QWidget::NoFocus );
 
     resizeEvent( 0 );
 }
 
 void VideoWidget::updateSlider( long i, long max ) {
     // Will flicker too much if we don't do this
     if ( max == 0 ) {
         return;
     }
     int width = slider->width();
     int val = int((double)i * width / max);
     if ( !mediaPlayerState.isFullscreen() && !videoSliderBeingMoved ) {
         if ( slider->value() != val ) {
             slider->setValue( val );
         }
         if ( slider->maxValue() != width ) {
             slider->setMaxValue( width );
         }
     }
 }
 
 void VideoWidget::mouseReleaseEvent( QMouseEvent *event ) {
     if ( mediaPlayerState.isFullscreen() ) {
         mediaPlayerState.setFullscreen( FALSE );
         makeVisible();
     }
     MediaWidget::mouseReleaseEvent( event );
 }
 
 void VideoWidget::backToNormal() {
      mediaPlayerState.setFullscreen( FALSE );
      makeVisible();
      setToggleButton( FullScreen, false );
 }
 
 void VideoWidget::makeVisible() {
     if ( mediaPlayerState.isFullscreen() ) {
         showFullScreen();
         resize( qApp->desktop()->size() );
         videoFrame-> setGeometry ( 0, 0, width ( ), height ( ));
 
         slider->hide();
         disconnect( &mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
         disconnect( &mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
         disconnect( slider, SIGNAL( sliderPressed() ), this, SLOT( sliderPressed() ) );
         disconnect( slider, SIGNAL( sliderReleased() ), this, SLOT( sliderReleased() ) );
 
     } else {
         showNormal();
         showMaximized();
         QWidget *d = QApplication::desktop();
         int w = d->width();
         int h = d->height();
 
         if(w>h) {
             int newW=(w/2)-(246/2); //this will only work with 320x240
             videoFrame->setGeometry( QRect( newW, 4, 240, 170  ) );
         } else {
             videoFrame->setGeometry( QRect( 0, 30, 240, 170  ) );
         }
 
         if ( !mediaPlayerState.isSeekable()  ) {
             if( !slider->isHidden()) {
                 slider->hide();
             }
             disconnect( &mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
             disconnect( &mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
             disconnect( slider, SIGNAL( sliderPressed() ), this, SLOT( sliderPressed() ) );
             disconnect( slider, SIGNAL( sliderReleased() ), this, SLOT( sliderReleased() ) );
         } else {
             slider->show();
             connect( &mediaPlayerState, SIGNAL( positionChanged(long) ),this, SLOT( setPosition(long) ) );
             connect( &mediaPlayerState, SIGNAL( positionUpdated(long) ),this, SLOT( setPosition(long) ) );
             connect( slider, SIGNAL( sliderPressed() ), this, SLOT( sliderPressed() ) );
             connect( slider, SIGNAL( sliderReleased() ), this, SLOT( sliderReleased() ) );
         }
     }
 }
 
 void VideoWidget::keyReleaseEvent( QKeyEvent *e) {
     switch ( e->key() ) {
 ////////////////////////////// Zaurus keys
       case Key_Home:
           break;
       case Key_F9: //activity
           break;
       case Key_F10: //contacts
 //           hide();
           break;
       case Key_F11: //menu
           break;
       case Key_F12: //home
           break;
       case Key_F13: //mail
           break;
       case Key_Space: {
           if(mediaPlayerState.isPlaying()) {
               mediaPlayerState.setPlaying(FALSE);
           } else {
               mediaPlayerState.setPlaying(TRUE);
           }
       }
           break;
       case Key_Down:
 //            toggleButton(6);
             emit lessClicked();
             emit lessReleased();
 //            toggleButton(6);
           break;
       case Key_Up:
 //             toggleButton(5);
              emit moreClicked();
              emit moreReleased();
 //             toggleButton(5);
            break;
       case Key_Right:
           mediaPlayerState.setNext();
           break;
       case Key_Left:
           mediaPlayerState.setPrev();
           break;
       case Key_Escape:
           break;
 
     };
 }
 
 XineVideoWidget* VideoWidget::vidWidget() {
     return videoFrame;
 }
 
 
 void VideoWidget::setFullscreen ( bool b ) {
     setToggleButton( FullScreen, b );
 }
 
 
 void VideoWidget::setPlaying( bool b) {
     setToggleButton( Play, b );
 }
 
diff --git a/noncore/multimedia/opieplayer2/volumecontrol.cpp b/noncore/multimedia/opieplayer2/volumecontrol.cpp
index 271b84e..b3f5f8d 100644
--- a/noncore/multimedia/opieplayer2/volumecontrol.cpp
+++ b/noncore/multimedia/opieplayer2/volumecontrol.cpp
@@ -1,61 +1,59 @@
 
-#include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include "qpe/qcopenvelope_qws.h"
-#include <qmessagebox.h>
 
 #include "volumecontrol.h"
 
 int VolumeControl::volume() {
     Config cfg( "qpe" );
     cfg. setGroup( "Volume" );
     m_volumePerc = cfg. readNumEntry( "VolumePercent", 50 );
     
     return m_volumePerc;
 }
 
 
 void VolumeControl::setVolume( int volumePerc ) {
      Config cfg("qpe");
     cfg.setGroup("Volume");
 
     if ( volumePerc > 100 ) {
         volumePerc = 100;
     }
     if ( volumePerc < 0 ) {
         volumePerc = 0;
     }
 
     m_volumePerc = volumePerc;
     cfg.writeEntry("VolumePercent", volumePerc );
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false;
 //    QCopEnvelope( "QPE/System", "setVolume(int,int)" ) << 0, volumePerc;
 }
 
 
 void VolumeControl::incVol( int ammount ) {
     int oldVol = volume();
     setVolume( oldVol + ammount);
 }
 
 void VolumeControl::decVol( int ammount ) {
      int oldVol = volume();
     setVolume( oldVol - ammount);
 }
 
 
 VolumeControl::VolumeControl( ) {
     volume();
 }
 
 VolumeControl::~VolumeControl() {
     QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false;
 }
 
 void VolumeControl::setMute(bool on) {
    QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << on;
 }
 
 
 
 
diff --git a/noncore/multimedia/opieplayer2/xinecontrol.cpp b/noncore/multimedia/opieplayer2/xinecontrol.cpp
index 70f2ffd..8f11b2e 100644
--- a/noncore/multimedia/opieplayer2/xinecontrol.cpp
+++ b/noncore/multimedia/opieplayer2/xinecontrol.cpp
@@ -1,272 +1,271 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Max Reiss <harlekin@handhelds.org>
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include <qtimer.h>
 #include <qmessagebox.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qpeapplication.h>
 
 #include "xinecontrol.h"
-#include "mediaplayerstate.h"
 #include "xinevideowidget.h"
 
 XineControl::XineControl( XineVideoWidget *xineWidget,
                           MediaPlayerState &_mediaPlayerState,
                           QObject *parent, const char *name )
     : QObject( parent, name ), mediaPlayerState( _mediaPlayerState ), xineVideoWidget( xineWidget )
 {
     libXine = new XINE::Lib( XINE::Lib::InitializeImmediately, xineWidget );
 
     init();
 }
 
 XineControl::XineControl( XINE::Lib *xine, XineVideoWidget *xineWidget,
                           MediaPlayerState &_mediaPlayerState,
                           QObject *parent, const char *name )
     : QObject( parent, name ), libXine( xine ), mediaPlayerState( _mediaPlayerState ), xineVideoWidget( xineWidget )
 {
     xine->ensureInitialized();
 
     xine->setWidget( xineWidget );
 
     init();
 }
 
 void XineControl::init()
 {
     connect( &mediaPlayerState, SIGNAL( pausedToggled(bool) ),  this, SLOT( pause(bool) ) );
     connect( this, SIGNAL( positionChanged(long) ), &mediaPlayerState, SLOT( updatePosition(long) ) );
     connect( &mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( stop(bool) ) );
     connect( &mediaPlayerState, SIGNAL( fullscreenToggled(bool) ), this, SLOT( setFullscreen(bool) ) );
     connect( &mediaPlayerState, SIGNAL( positionChanged(long) ),  this,  SLOT( seekTo(long) ) );
     connect( &mediaPlayerState,  SIGNAL( videoGammaChanged(int) ), this,  SLOT( setGamma(int) ) );
     connect( libXine, SIGNAL( stopped() ), this, SLOT( nextMedia() ) );
     connect( xineVideoWidget, SIGNAL( videoResized(const QSize&) ), this, SLOT( videoResized(const QSize&) ) );
 
     disabledSuspendScreenSaver = FALSE;
 }
 
 XineControl::~XineControl() {
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( disabledSuspendScreenSaver ) {
         disabledSuspendScreenSaver = FALSE;
         // Re-enable the suspend mode
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
     }
 #endif
     delete libXine;
 }
 
 void XineControl::play( const QString& fileName ) {
 
     hasVideoChannel = FALSE;
     hasAudioChannel = FALSE;
     m_fileName = fileName;
 
     qDebug("<<FILENAME: " + fileName  + ">>>>");
 
     if ( !libXine->play( fileName, 0, 0 ) ) {
         QMessageBox::warning( 0l , tr( "Failure" ), getErrorCode() );
         // toggle stop so the the play button is reset
         mediaPlayerState.setPlaying( false );
         return;
     }
     mediaPlayerState.setPlaying( true );
 
     MediaPlayerState::DisplayType displayType;
     if ( !libXine->hasVideo() ) {
         displayType = MediaPlayerState::Audio;
         qDebug("HAS AUDIO");
         libXine->setShowVideo( false );
         hasAudioChannel = TRUE;
     } else {
         displayType = MediaPlayerState::Video;
         qDebug("HAS VIDEO");
         libXine->setShowVideo( true );
         hasVideoChannel = TRUE;
     }
     // determine if slider is shown
     mediaPlayerState.setIsSeekable( libXine->isSeekable() );
 
     // which gui (video / audio)
     mediaPlayerState.setDisplayType( displayType );
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
     if ( !disabledSuspendScreenSaver ) {
         disabledSuspendScreenSaver = TRUE;
         // Stop the screen from blanking and power saving state
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" )
             << ( displayType == MediaPlayerState::Video ? QPEApplication::Disable : QPEApplication::DisableSuspend );
     }
 #endif
 
     length();
     position();
 }
 
 void XineControl::nextMedia() {
     mediaPlayerState.setNext();
 }
 
 void XineControl::setGamma( int value ) {
     libXine->setGamma( value );
 }
 
 void XineControl::stop( bool isSet ) {
     if ( !isSet ) {
         libXine->stop();
 
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
         if ( disabledSuspendScreenSaver ) {
             disabledSuspendScreenSaver = FALSE;
             // Re-enable the suspend mode
             QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
         }
 #endif
     }
 }
 
 /**
  * Pause playback
  * @isSet
  */
 void XineControl::pause( bool isSet) {
     libXine->pause( isSet );
 }
 
 
 /**
  * get current time in playback
  */
 long XineControl::currentTime() {
     // todo: jede sekunde überprüfen
     m_currentTime = libXine->currentTime();
     return m_currentTime;
     QTimer::singleShot( 1000, this, SLOT( currentTime() ) );
 }
 
 /**
  * Set the length of the media file
  */
 void  XineControl::length() {
     m_length = libXine->length();
     mediaPlayerState.setLength( m_length );
 }
 
 
 /**
  * Reports the position the xine backend is at right now
  * @return long the postion in seconds
  */
 long XineControl::position() {
     m_position = ( currentTime() );
     mediaPlayerState.updatePosition( m_position );
     long emitPos = (long)m_position;
     emit positionChanged( emitPos );
     if( mediaPlayerState.isPlaying() ) {
     // needs to be stopped the media is stopped
         QTimer::singleShot( 1000, this, SLOT( position() ) );
     }
     return m_position;
 }
 
 /**
  * Set videoplayback to fullscreen
  * @param isSet
  */
 void XineControl::setFullscreen( bool isSet ) {
     libXine->showVideoFullScreen( isSet );
 }
 
 
 QString XineControl::getMetaInfo() {
 
     QString returnString;
 
     if ( !libXine->metaInfo( 0 ).isEmpty() ) {
         returnString += tr( " Title: " + libXine->metaInfo( 0 ) );
     }
 
     if ( !libXine->metaInfo( 1 ).isEmpty() ) {
         returnString += tr( " Comment: " + libXine->metaInfo( 1 ) );
     }
 
     if ( !libXine->metaInfo( 2 ).isEmpty() ) {
         returnString += tr( " Artist: " + libXine->metaInfo( 2 ) );
     }
 
     if ( !libXine->metaInfo( 3 ).isEmpty() ) {
         returnString += tr( " Genre: " + libXine->metaInfo( 3 ) );
     }
 
     if ( !libXine->metaInfo( 4 ).isEmpty() ) {
         returnString += tr( " Album: " + libXine->metaInfo( 4 ) );
     }
 
     if ( !libXine->metaInfo( 5 ).isEmpty() ) {
         returnString += tr( " Year: " + libXine->metaInfo( 5 ) );
     }
     return returnString;
 }
 
 QString XineControl::getErrorCode() {
 
     int errorCode = libXine->error();
 
     qDebug( QString("ERRORCODE: %1 ").arg(errorCode) );
 
     if ( errorCode == 1 ) {
         return tr( "No input plugin found for this media type" );
     } else if ( errorCode == 2 ) {
          return tr( "No demux plugin found for this media type" );
     } else if ( errorCode == 3 ) {
         return tr( "Demuxing failed for this media type" );
     } else if ( errorCode == 4 ) {
         return tr( "Malformed MRL" );
     } else {
         return tr( "Some other error" );
     }
 }
 
 /**
  * Seek to a position in the track
  * @param second the second to jump to
  */
 void XineControl::seekTo( long second ) {
     libXine->seekTo( (int)second );
 }
 
 void XineControl::videoResized ( const QSize &s ) {
     libXine->resize( s );
 }
diff --git a/noncore/multimedia/opieplayer2/xinevideowidget.cpp b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
index 0833784..b55750a 100644
--- a/noncore/multimedia/opieplayer2/xinevideowidget.cpp
+++ b/noncore/multimedia/opieplayer2/xinevideowidget.cpp
@@ -1,278 +1,275 @@
 
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
                              Copyright (c)  2002 Holger Freyther <zecke@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include <qimage.h>
-#include <qpainter.h>
-#include <qgfx_qws.h>
 #include <qdirectpainter_qws.h>
 #include <qgfx_qws.h>
 #include <qsize.h>
 #include <qapplication.h>
-#include <qpainter.h>
 
 #include <qpe/resource.h>
 
 #include "xinevideowidget.h"
 
 
 // 0 deg rot: copy a line from src to dst (use libc memcpy)
 
 // 180 deg rot: copy a line from src to dst reversed
 
 static inline void memcpy_rev ( void *dst, void *src, size_t len )
 {
         len >>= 1;
 
         ((char *) src ) += ( len << 1 );
 
         while ( len-- )
                 *((short int *) dst )++ = *--((short int *) src );
 }
 
 // 90 deg rot: copy a column from src to dst
 
 static inline void memcpy_step ( void *dst, void *src, size_t len, size_t step )
 {
         len >>= 1;
         while ( len-- ) {
                 *((short int *) dst )++ = *((short int *) src );
                 ((char *) src ) += step;
         }
 }
 
 // 270 deg rot: copy a column from src to dst reversed
 
 static inline void memcpy_step_rev ( void *dst, void *src, size_t len, size_t step )
 {
         len >>= 1;
 
         ((char *) src ) += ( len * step );
 
         while ( len-- ) {
                 ((char *) src ) -= step;
                 *((short int *) dst )++ = *((short int *) src );
         }
 }
 
 
 XineVideoWidget::XineVideoWidget ( QWidget* parent, const char* name )
         : QWidget ( parent, name, WRepaintNoErase | WResizeNoErase )
 {
         setBackgroundMode ( NoBackground );
 
         m_logo              = 0;
         m_buff              = 0;
         m_bytes_per_line_fb = qt_screen-> linestep ( );
         m_bytes_per_pixel   = ( qt_screen->depth() + 7 ) / 8;
         m_rotation          = 0;
 }
 
 
 XineVideoWidget::~XineVideoWidget ( )
 {
         delete m_logo;
 }
 
 void XineVideoWidget::clear ( )
 {
         m_buff = 0;
         repaint ( false );
 }
 
 QSize XineVideoWidget::videoSize() const
 {
     QSize s = size();
     bool fs = ( s == qApp->desktop()->size() );
 
     // if we are in fullscreen mode, do not rotate the video
     // (!! the paint routine uses m_rotation + qt_screen-> transformOrientation() !!)
     m_rotation = fs ? - qt_screen->transformOrientation() : 0;
 
     if ( fs && qt_screen->isTransformed() )
         s = qt_screen->mapToDevice( s );
 
     return s;
 }
 
 void XineVideoWidget::paintEvent ( QPaintEvent * )
 {
         if ( m_buff == 0 ) {
                 QPainter p ( this );
                 p. fillRect ( rect ( ), black );
                 if ( m_logo )
                         p. drawImage ( 0, 0, *m_logo );
         }
         else {
                 // Qt needs to be notified which areas were really updated .. strange
                 QArray <QRect> qt_bug_workaround_clip_rects;
 
                 {
                         QDirectPainter dp ( this );
 
                         int rot = dp. transformOrientation ( ) + m_rotation; // device rotation + custom rotation
 
                         uchar *fb = dp. frameBuffer ( );
                         uchar *frame = m_buff;
 
                         // where is the video frame in fb coordinates
                         QRect framerect = qt_screen-> mapToDevice ( QRect ( mapToGlobal ( m_thisframe. topLeft ( )), m_thisframe. size ( )), QSize ( qt_screen-> width ( ), qt_screen-> height ( )));
 
                         qt_bug_workaround_clip_rects. resize ( dp. numRects ( ));
 
                         for ( int i = dp. numRects ( ) - 1; i >= 0; i-- ) {
                                 const QRect &clip = dp. rect ( i );
 
                                 qt_bug_workaround_clip_rects [ i ] = qt_screen-> mapFromDevice ( clip, QSize ( qt_screen-> width ( ), qt_screen-> height ( )));
 
                                         uchar *dst = fb + ( clip. x ( ) * m_bytes_per_pixel ) + ( clip. y ( ) * m_bytes_per_line_fb ); // clip x/y in the fb
                                 uchar *src = frame;
 
                                 // Adjust the start the source data based on the rotation (xine frame)
                                 switch ( rot ) {
                                         case  0: src += ((( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame )); break;
                                         case  1: src += ((( clip. y ( ) - framerect. y ( )) * m_bytes_per_pixel ) + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_line_frame ) + (( framerect. height ( ) - 1 ) * m_bytes_per_pixel )); break;
                                         case  2: src += ((( clip. x ( ) - framerect. x ( )) * m_bytes_per_pixel ) + (( clip. y ( ) - framerect. y ( )) * m_bytes_per_line_frame ) + (( framerect. height ( ) - 1 ) * m_bytes_per_line_frame )); break;
                                         case  3: src += ((( clip. y ( ) - framerect. y ( )) * m_bytes_per_pixel ) + (( clip. x ( ) - framerect. x ( )) * m_bytes_per_line_frame )); break;
                                         default: break;
                                 }
 
                                 // all of the following widths/heights are fb relative (0deg rotation)
 
                                 uint leftfill = 0;   // black border on the "left" side of the video frame
                                 uint framefill = 0;  // "width" of the video frame
                                 uint rightfill = 0;  // black border on the "right" side of the video frame
                                 uint clipwidth = clip. width ( ) * m_bytes_per_pixel;  // "width" of the current clip rect
 
                                 if ( clip. left ( ) < framerect. left ( ))
                                         leftfill = (( framerect. left ( ) - clip. left ( )) * m_bytes_per_pixel ) <? clipwidth;
                                 if ( clip. right ( ) > framerect. right ( ))
                                         rightfill = (( clip. right ( ) - framerect. right ( )) * m_bytes_per_pixel ) <? clipwidth;
 
                                 framefill = clipwidth - ( leftfill + rightfill );
 
                                 for ( int y = clip. top ( ); y <= clip. bottom ( ); y++ ) {
                                         if (( y < framerect. top ( )) || ( y > framerect. bottom ( ))) {
                                                 // "above" or "below" the video -> black
                                                 memset ( dst, 0, clipwidth );
                                         }
                                         else {
                                                 if ( leftfill )
                                                         memset ( dst, 0, leftfill ); // "left" border -> black
 
                                                 if ( framefill ) { // blit in the video frame
                                                         // see above for an explanation of the different memcpys
 
                                                         switch ( rot ) {
                                                                 case  0: memcpy ( dst + leftfill, src, framefill & ~1 ); break;
                                                                 case  1: memcpy_step ( dst + leftfill, src, framefill, m_bytes_per_line_frame ); break;
                                                                 case  2: memcpy_rev ( dst + leftfill, src, framefill ); break;
                                                                 case  3: memcpy_step_rev ( dst + leftfill, src, framefill, m_bytes_per_line_frame ); break;
                                                                 default: break;
                                                         }
                                                 }
                                                 if ( rightfill )
                                                         memset ( dst + leftfill + framefill, 0, rightfill ); // "right" border -> black
                                         }
 
                                         dst += m_bytes_per_line_fb; // advance one line in the framebuffer
 
                                         // advance one "line" in the xine frame data
                                         switch ( rot ) {
                                                         case  0: src += m_bytes_per_line_frame;break;
                                                 case  1: src -= m_bytes_per_pixel;      break;
                                                 case  2: src -= m_bytes_per_line_frame; break;
                                                 case  3: src += m_bytes_per_pixel;      break;
                                                 default: break;
                                         }
                                 }
                         }
                 }
 
                 {
                         // QVFB hack by Martin Jones
                         // We need to "touch" all affected clip rects with a normal QPainter in addition to the QDirectPainter
 
                         QPainter p ( this );
 
                         for ( int i = qt_bug_workaround_clip_rects. size ( ) - 1; i >= 0; i-- ) {
                                 p. fillRect ( QRect ( mapFromGlobal ( qt_bug_workaround_clip_rects [ i ]. topLeft ( )), qt_bug_workaround_clip_rects [ i ]. size ( )), QBrush ( NoBrush ));
                         }
                 }
         }
 }
 
 
 QImage *XineVideoWidget::logo ( ) const
 {
         return m_logo;
 }
 
 
 void XineVideoWidget::setLogo ( QImage* logo )
 {
         delete m_logo;
         m_logo = logo;
 }
 
 void XineVideoWidget::setVideoFrame ( uchar* img, int w, int h, int bpl )
 {
         bool rot90 = (( -m_rotation ) & 1 );
 
         if ( rot90 ) { // if the rotation is 90 or 270 we have to swap width / height
                 int d = w;
                 w = h;
                 h = d;
         }
 
         m_lastframe = m_thisframe;
         m_thisframe. setRect (( width ( ) - w ) / 2, ( height ( ) - h ) / 2, w , h );
 
         m_buff                 = img;
         m_bytes_per_line_frame = bpl;
 
         // only repaint the area that *really* needs to be repainted
 
         repaint ((( m_thisframe & m_lastframe ) != m_lastframe ) ? m_lastframe : m_thisframe, false );
 }
 
 void XineVideoWidget::resizeEvent ( QResizeEvent * )
 {
     emit videoResized( videoSize() );
 }
 
 
 void XineVideoWidget::mouseReleaseEvent ( QMouseEvent * /*me*/ )
 {
         emit clicked();
 }
 
diff --git a/noncore/multimedia/opierec/main.cpp b/noncore/multimedia/opierec/main.cpp
index 714907c..74a175b 100644
--- a/noncore/multimedia/opierec/main.cpp
+++ b/noncore/multimedia/opierec/main.cpp
@@ -1,30 +1,29 @@
 /***************************************************************************
  main.cpp  -  main routine
  ***************************************************************************/
 //// main.cpp
 ////  copyright 2001, 2002, by L. J. Potter <ljp@llornkcor.com>
 /***************************************************************************
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 #include "qtrec.h"
-#include <qpe/qpeapplication.h>
 
 #ifdef PDAUDIO
 int main(int argc, char* argv[]) {
     QPEApplication a(argc, argv);
     QtRec qtrec;
     a.showMainWidget( &qtrec);
  return a.exec();
 }
 
 
 #else
 #include <opie/oapplicationfactory.h>
 OPIE_EXPORT_APP( OApplicationFactory<QtRec> )
 
 #endif
 
 
diff --git a/noncore/multimedia/opierec/qtrec.cpp b/noncore/multimedia/opierec/qtrec.cpp
index f2035ef..1c64ab1 100644
--- a/noncore/multimedia/opierec/qtrec.cpp
+++ b/noncore/multimedia/opierec/qtrec.cpp
@@ -1,2133 +1,2132 @@
 /****************************************************************************
          // qtrec.cpp
  Created: Thu Jan 17 11:19:58 2002
  copyright 2002 by L.J. Potter <ljp@llornkcor.com>
 ****************************************************************************/
 #define DEV_VERSION
 
 #include "pixmaps.h"
 #include "qtrec.h"
 #include "waveform.h"
-#include "device.h"
 
 #include <pthread.h>
 
 extern "C" {
 #include "adpcm.h"
 }
 
 #include <sys/soundcard.h>
 
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
 
 #include <qcheckbox.h>
 #include <qcombobox.h>
 //#include <qdatetime.h>
 #include <qdir.h>
 #include <qgroupbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlistview.h>
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qslider.h>
 #include <qtabwidget.h>
 #include <qtimer.h>
 
 #include <errno.h>
 #include <fcntl.h>
 #include <math.h>
 #include <mntent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/vfs.h>
 #include <unistd.h>
 #include <sys/wait.h>
 #include <sys/signal.h>
 
 
 #ifdef PDAUDIO //ALSA
 #include <alsa/asoundlib.h>
 static int deviceSampleRates[8] = { 32000, 44100, 48000, 88200, 96000, 176400, 192000, -1 };
 static int deviceBitRates[] = { 8, 16, 24, 32, -1 };
 #else //OSS
 static int deviceSampleRates[6] = { 11025, 16000, 22050, 32000, 44100, -1 };
 static int deviceBitRates[] = { 8, 16, -1 };
 #endif
 
 #if defined(QT_QWS_SL5XXX)
 ///#if defined(QT_QWS_EBX)
 
 #define DSPSTROUT "/dev/dsp"
 #define DSPSTRIN "/dev/dsp1"
 #define DSPSTRMIXEROUT "/dev/mixer"
 #define DSPSTRMIXERIN "/dev/mixer1"
 
 #else
 
 #define DSPSTROUT "/dev/dsp"
 #define DSPSTRIN "/dev/dsp"
 #define DSPSTRMIXERIN "/dev/mixer"
 #define DSPSTRMIXEROUT "/dev/mixer"
 
 #endif
 
 //#define ZAURUS 0
 struct adpcm_state encoder_state;
 struct adpcm_state decoder_state;
 
 typedef struct {
                 int sampleRate;
                         /*      int fragSize; */
                         /*      int blockSize; */
                 int resolution; //bitrate
                 int channels; //number of channels
                 int fd; //file descriptor
                 int sd; //sound device descriptor
                 int numberSamples; //total number of samples
                 int SecondsToRecord; // number of seconds that should be recorded
                 float numberOfRecordedSeconds; //total number of samples recorded
                 int samplesToRecord; //number of samples to be recorded
                 int inVol; //input volume
                 int outVol; //output volume
                 int format; //wavfile format PCM.. ADPCM
                 const  char *fileName; //name of fiel to be played/recorded
 } fileParameters;
 
 fileParameters filePara;
 
 bool monitoring, recording, playing;
 bool stopped;
 QLabel *timeLabel;
 QSlider *timeSlider;
 int sd;
 
 Waveform* waveform;
 Device *soundDevice;
 
 
 #ifdef THREADED
 void quickRec()
 #else
                 void QtRec::quickRec() 
 #endif
 {
                 
                 qDebug("%d",
                                          filePara.numberSamples/filePara.sampleRate * filePara.channels);
                 qDebug("samples %d, rate %d, channels %d",
                                          filePara.numberSamples, filePara.sampleRate, filePara.channels);
 
                 int total = 0;  // Total number of bytes read in so far.
                 int bytesWritten, number;
 
                 bytesWritten = 0;
                 number = 0;
                 QString num;
                 int level = 0;
                 int threshold = 0;
 //   int bits = filePara.resolution;
 //   qDebug("bits %d", bits);
 
                 if( filePara.resolution == 16 ) { //AFMT_S16_LE)
 //       qDebug("AFMT_S16_LE size %d", filePara.SecondsToRecord);
 //       qDebug("samples to record %d", filePara.samplesToRecord);
 //       qDebug("%d", filePara.sd);
                                 level = 7;
                                 threshold = 0;
 
                                 if( filePara.format == WAVE_FORMAT_DVI_ADPCM) {
 //          qDebug("start recording WAVE_FORMAT_DVI_ADPCM");
                                                         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_DVI_ADPCM  >>>>>>>>>>>>>>>>>>>>>>
                                                 char abuf[ BUFSIZE/2 ];
                                                 short sbuf[ BUFSIZE ];
                                                 short sbuf2[ BUFSIZE ];
                                                 memset( abuf, 0, BUFSIZE/2);
                                                 memset( sbuf, 0, BUFSIZE);
                                                 memset( sbuf2, 0, BUFSIZE);
 
                                                 for(;;) {
                                                                 if ( stopped) {
         //                                                                      qDebug("quickRec:: stopped");
                                                                                 break;
                                                                 }
 
 //             number=::read( filePara.sd, sbuf, BUFSIZE);
                                                                 number =  soundDevice ->devRead( filePara.sd, sbuf, BUFSIZE);
 
                                                                 if(number <= 0) {
                                                                                 perror("recording error ");
                                                                                 qDebug( "%s %d", filePara.fileName, number);
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
                                                                         //if(stereo == 2) {
 //        adpcm_coder( sbuf2, abuf, number/2, &encoder_state);
                                                                 adpcm_coder( sbuf, abuf, number/2, &encoder_state);
 
                                                                 bytesWritten = ::write( filePara.fd , (short *)abuf, number/4);
 
                                                                 waveform->newSamples( (const short *)abuf, bytesWritten );
 
                                                                 total += bytesWritten;
                                                                 filePara.numberSamples = total;
                                                                 timeSlider->setValue( total);
 
                                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate * (float)2 / filePara.channels;
 
                                                                 qApp->processEvents();
                                                                 if( total >= filePara.samplesToRecord) {
                                                                                 stopped = true;
                                                                                 break;
                                                                 }
                                                 }
                                 } else {
                                                         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_PCM   >>>>>>>>>>>>>>>>>>>>>>
                                                 qDebug("start recording WAVE_FORMAT_PCM");
                                                 short inbuffer[ BUFSIZE ], outbuffer[ BUFSIZE ];
                                                 memset( inbuffer, 0, BUFSIZE);
                                                 memset( outbuffer, 0, BUFSIZE);
 
                                                 for(;;) {
                                                                 if ( stopped) {
                                                                                 qDebug("quickRec:: stopped");
                                                                                 stopped = true;
                                                                                 break;  // stop if playing was set to false
                                                                                 return;
                                                                 }
 
                                                                 number = soundDevice->devRead( filePara.sd, (short *)inbuffer, BUFSIZE);
                                                                 waveform->newSamples( inbuffer, number );
 
                                                                 if( number <= 0) {
                                                                                 perror( "recording error ");
                                                                                 qDebug( filePara.fileName);
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
 
                                                                 bytesWritten = ::write( filePara.fd , inbuffer, number);
 
                                                                 if( bytesWritten < 0) {
                                                                                 perror("File writing error ");
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
 
                                                                 total += bytesWritten;
 
                                                                 filePara.numberSamples = total;
 
                                                                 if( filePara.SecondsToRecord != 0)
                                                                                 timeSlider->setValue( total);
 //         printf("Writing number %d, bytes %d,total %d\r",number,  bytesWritten , total);
 //         fflush(stdout);
 
                                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / (float)2/filePara.channels;
                                                                 qApp->processEvents();
 
                                                                 if( total >= filePara.samplesToRecord) {
                                                                                 stopped = true;
                                                                                 break;
                                                                 }
                                                 }
                                 } //end main loop
 
                 } else {
 // <<<<<<<<<<<<<<<<<<<<<<<   format = AFMT_U8;
                                 unsigned char unsigned_inbuffer[ BUFSIZE ], unsigned_outbuffer[ BUFSIZE ];
                                 memset( unsigned_inbuffer, 0, BUFSIZE);
                                 memset( unsigned_outbuffer, 0, BUFSIZE);
 
                                 for(;;) {
                                                 if ( stopped) {
                                                                 qDebug("quickRec:: stopped");
                                                                 break;  // stop if playing was set to false
                                                 }
          
                                                 number = ::read( filePara.sd, unsigned_inbuffer, BUFSIZE);
                                                 bytesWritten = ::write( filePara.fd , unsigned_inbuffer, number);
 
                                                 if(bytesWritten < 0) {
                                                                 stopped = true;
                                                                 QMessageBox::message("Note","There was a problem\nwriting to the file");
                                                                 perror("File writing error ");
                                                                 return;
                                                 }
 
                                                 total += bytesWritten;
                                                 filePara.numberSamples = total;
                                                         //             printf("\nWriting number %d, bytes %d,total %d \r",number,  bytesWritten , total);
                                                         //             fflush(stdout);
                                                 if( filePara.SecondsToRecord !=0)
                                                                 timeSlider->setValue( total);
 
                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate;
 
                                                 qApp->processEvents();
                                                 if( total >= filePara.samplesToRecord) {
                                                                 stopped = true;
                                                                 break;
                                                 }
                                 } //end main loop
                 }
 } /// END quickRec()
 
 
 #ifdef THREADED
 void playIt()
 #else
                 void QtRec::playIt()
 #endif
 {
                 int bytesWritten = 0;
                 int number = 0;
                 int total = 0;  // Total number of bytes read in so far.
                 if( filePara.resolution == 16 ) { //AFMT_S16_LE) {
                                 if( filePara.format == WAVE_FORMAT_DVI_ADPCM) {
                                                 char abuf[ BUFSIZE / 2 ];
                                                 short sbuf[ BUFSIZE ];
                                                 short sbuf2[ BUFSIZE * 2 ];
                                                 memset( abuf, 0, BUFSIZE / 2);
                                                 memset( sbuf, 0, BUFSIZE);
                                                 memset( sbuf2, 0, BUFSIZE * 2);
 // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_DVI_ADPCM  >>>>>>>>>>>>>>>>>>>>>>
                                                 for(;;) {  // play loop
                                                                 if ( stopped) {
                                                                                 break;
                                                                                 return;
                                                                 }// stop if playing was set to false
 
                                                                 number = ::read( filePara.fd, abuf, BUFSIZE / 2);
                                                                 adpcm_decoder( abuf, sbuf, number * 2, &decoder_state);
 
 //                 for (int i=0;i< number * 2; 2 * i++) { //2*i is left channel
 //                     sbuf2[i+1]=sbuf2[i]=sbuf[i];
 //                 }
                                                                 bytesWritten = write ( filePara.sd, sbuf, number * 4);
                                                                 waveform->newSamples( (const short *)sbuf, number );
                                                                         //          if(filePara.channels==1)
                                                                         //              total += bytesWritten/2; //mono
                                                                         //          else
                                                                 total += bytesWritten;
                                                                 filePara.numberSamples = total/4;
                                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / 2;
 
                                                                 timeSlider->setValue( total/4);
 //            timeString.sprintf("%.2f", filePara.numberOfRecordedSeconds);
 //         if(filePara.numberOfRecordedSeconds>1)
 //            timeLabel->setText( timeString+ tr(" seconds"));
         //                                                      printf("playing number %d, bytes %d, total %d\n",number,  bytesWritten, total/4);
         //                                                      fflush(stdout);
 
                                                                 qApp->processEvents();
 
                                                                 if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
 //            if( total >= filePara.numberSamples ){//||  secCount > filePara.numberOfRecordedSeconds ) {
                                                                                 stopped = true;
                                                                                 break;
                                                                 }
                                                 }
                                 } else {
                                                         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_PCM   >>>>>>>>>>>>>>>>>>>>>>
                                                 short inbuffer[ BUFSIZE ], outbuffer[ BUFSIZE ];
                                                 memset( inbuffer, 0, BUFSIZE);
                                                 memset( outbuffer, 0, BUFSIZE);
 
                                                 for(;;) {  // play loop
                                                                 if ( stopped) {
                                                                                 break;
                                                                                 return;
                                                                 }
 // stop if playing was set to false
                                                                 number = ::read( filePara.fd, inbuffer, BUFSIZE);
 //                 for (int i=0;i< number * 2; 2 * i++) { //2*i is left channel
 //                       //        for (int i=0;i< number ; i++) { //2*i is left channel
 //                     outbuffer[i+1]= outbuffer[i]=inbuffer[i];
 //                 }
                                                                 bytesWritten = ::write( filePara.sd, inbuffer, number);
                                                                 waveform->newSamples( inbuffer, bytesWritten );
                                                                         //-------------->>>> out to device
                                                                         //        total+=bytesWritten;
                                                                         //          if(filePara.channels==1)
                                                                         //              total += bytesWritten/2; //mono
                                                                         //          else
                                                                 total += bytesWritten;
                                                                 timeSlider->setValue( total);
 
                                                                 filePara.numberSamples = total;
                                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / (float)2;
 
 //             timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
 //             timeLabel->setText( timeString + tr(" seconds"));
 
                                                                 qApp->processEvents();
 
                                                                 if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
                                                                                 qWarning("Jane! Stop this crazy thing!");
                                                                                 stopped = true;
 //                playing = false;
                                                                                 break;
                                                                 }
                                                 }
             printf("\nplaying number %d, bytes %d, total %d\r",number,  bytesWritten, total);
             fflush(stdout);
                                 } //end loop
                 } else {
 /////////////////////////////// format = AFMT_U8;
                                 unsigned char unsigned_inbuffer[ BUFSIZE ]; //, unsigned_outbuffer[BUFSIZE];
                                 memset( unsigned_inbuffer, 0, BUFSIZE);
                                 for(;;) {
 // main loop
                                                 if (stopped) {
                                                                 break;  // stop if playing was set to false
                                                                 return;
                                                 }
                                                 number = ::read( filePara.fd, unsigned_inbuffer, BUFSIZE);
 //data = (val >> 8) ^ 0x80;
                                                         //          unsigned_outbuffer = (unsigned_inbuffer >> 8) ^ 0x80;
                                                 bytesWritten = write ( filePara.sd, unsigned_inbuffer, number);
                                                 waveform->newSamples(  (const short *)unsigned_inbuffer, bytesWritten );
                                                 total += bytesWritten;
 
             timeSlider->setValue( total);
                                                 filePara.numberSamples = total;
 
                                                 filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate;
 //          timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
 //          timeLabel->setText( timeString + tr(" seconds"));
                                                 qApp->processEvents();
 
                                                 if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
 //         if( total >= filePara.numberSamples ) {
                                                                 stopped = true;
                                                                 break;
                                                 }
         //                                      printf("Writing number %d, bytes %d, total %d, numberSamples %d\r",number,  bytesWritten , total, filePara.numberSamples);
         //                                      fflush(stdout);
                                 }
                 }
 }
 
 
 QtRec::QtRec( QWidget* parent,  const char* name, WFlags fl )
                                 : QWidget( parent, name, fl )
 {
                 if ( !name )
                                 setName( "OpieRec" );
                 init();
                 initConfig();
                 initConnections();
                 renameBox = 0;
 
 // open sound device to get volumes
                 Config hwcfg("OpieRec");
                 hwcfg.setGroup("Hardware");
 
                 
                 soundDevice = new Device( this,
                                                                                                                         hwcfg.readEntry( "Audio",DSPSTROUT),
                                                                                                                         hwcfg.readEntry( "Mixer",DSPSTRMIXEROUT), false);
         //      soundDevice = new Device( this, hwcfg.readEntry( "Audio","hw:0"), hwcfg.readEntry( "Mixer","hw:0"), false);
 
 //     soundDevice->setDeviceFormat(AFMT_S16_LE);
 //     soundDevice->setDeviceChannels(1);
 //     soundDevice->setDeviceRate( 22050);
 
                 getInVol();
                 getOutVol();
 
                 soundDevice->closeDevice( true);
                 soundDevice->sd = -1;
                 soundDevice = 0;
                 wavFile = 0;
 
                 if( soundDevice) delete soundDevice;
 
                 initIconView();
 
                 if( autoMute)
                                 doMute( true);
                 ListView1->setFocus();
                 playing = false;
 }
 
 QtRec::~QtRec() {
 
 }
 
 void QtRec::cleanUp() {
 
                 if( !stopped) {
                                 stopped = true;
                                 endRecording();
                 }
 
                 ListView1->clear();
 
                 if( autoMute)
                                 doMute(false);
 
                 if( wavFile) delete wavFile;
 // if(soundDevice) delete soundDevice;
 }
 
 void QtRec::init() {
 
                 needsStereoOut = false;
                 QPixmap image3( ( const char** ) image3_data );
                 QPixmap image4( ( const char** ) image4_data );
                 QPixmap image6( ( const char** ) image6_data );
 
                 stopped = true;
                 setCaption( tr( "OpieRecord " ) + QString::number(VERSION) );
                 QGridLayout *layout = new QGridLayout( this );
                 layout->setSpacing( 2);
                 layout->setMargin( 2);
 
                 TabWidget = new QTabWidget( this, "TabWidget" );
                 layout->addMultiCellWidget(TabWidget, 0, 7, 0, 7);
 //    TabWidget->setTabShape(QTabWidget::Triangular);
 
                         ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
                 tab = new QWidget( TabWidget, "tab" );
 
                 QGridLayout *layout1 = new QGridLayout( tab);
                 layout1->setSpacing( 2);
                 layout1->setMargin( 2);
 
                 timeSlider = new QSlider( 0,100,10,0, QSlider::Horizontal, tab, (const char *) "timeSlider" );
                 layout1->addMultiCellWidget( timeSlider, 1, 1, 0, 3);
 
                 timeLabel = new QLabel( tab, "TimeLabel" );
                 layout1->addMultiCellWidget( timeLabel, 0, 0, 0, 3);
 
                 playLabel2 = new QLabel(tab, "PlayLabel2" );
                 playLabel2->setText(tr("Play") );
                 playLabel2->setFixedHeight( 18);
                 layout1->addMultiCellWidget( playLabel2, 0, 0, 4, 4);
 
                 Stop_PushButton = new QPushButton(  tab, "Stop_PushButton" );
                 layout1->addMultiCellWidget( Stop_PushButton, 1, 1, 4, 4);
                 Stop_PushButton->setFixedSize( 22, 22);
                 Stop_PushButton->setPixmap( image4 );
 
                 toBeginningButton = new QPushButton(  tab, "Beginning_PushButton" );
                 layout1->addMultiCellWidget(toBeginningButton, 1, 1, 5, 5);
                 toBeginningButton->setFixedSize( 22, 22);
                 toBeginningButton->setPixmap( Resource::loadPixmap("fastback") );
 
                 toEndButton = new QPushButton(  tab, "End_PushButton" );
                 layout1->addMultiCellWidget( toEndButton, 1, 1, 6, 6);
                 toEndButton->setFixedSize( 22, 22);
                 toEndButton->setPixmap(  Resource::loadPixmap( "fastforward" )  );
 
                 QLabel *recLabel2;
                 recLabel2 = new QLabel( tab, "recLabel2" );
                 recLabel2->setText(tr("Rec"));
                 recLabel2->setFixedHeight( 18);
                 layout1->addMultiCellWidget( recLabel2, 0, 0, 7, 7);
 
                 Rec_PushButton = new QPushButton( tab, "Rec_PushButton" );
                 layout1->addMultiCellWidget(  Rec_PushButton, 1, 1, 7, 7);
                 Rec_PushButton->setFixedSize( 22, 22);
                 Rec_PushButton->setPixmap( image6 );
 
                 t = new QTimer( this );
                 connect( t, SIGNAL( timeout() ), SLOT( timerBreak() ) );
 
                 rewindTimer = new QTimer( this );
                 connect( rewindTimer, SIGNAL( timeout() ),
                                                  this, SLOT( rewindTimerTimeout() ) );
 
                 forwardTimer = new QTimer( this );
                 connect( forwardTimer, SIGNAL( timeout() ),
                                                  this, SLOT( forwardTimerTimeout() ) );
 
                 deleteSoundButton  = new QPushButton( tab, "deleteSoundButton" );
                 layout1->addMultiCellWidget( deleteSoundButton, 1, 1, 8, 8);
                 deleteSoundButton->setText( tr( "Delete" ) );
 
                 ListView1 = new QListView( tab, "IconView1" );
                 layout1->addMultiCellWidget( ListView1, 2, 2, 0, 8);
 
                 ListView1->addColumn( tr( "Name" ) );
                 ListView1->setColumnWidth( 0, 140);
                 ListView1->setSorting( 1, false);
                 ListView1->addColumn( tr( "Time" ) ); //in seconds
                 ListView1->setColumnWidth( 1, 50);
                 ListView1->addColumn( tr("Location") );
                 ListView1->setColumnWidth( 2, 50);
                 ListView1->addColumn( tr("Date") );
                 ListView1->setColumnWidth( 3, 63);
 
                 ListView1->setColumnWidthMode( 0, QListView::Manual);
                 ListView1->setColumnAlignment( 1, QListView::AlignCenter);
                 ListView1->setColumnAlignment( 2, QListView::AlignRight);
                 ListView1->setColumnAlignment( 3, QListView::AlignLeft);
                 ListView1->setAllColumnsShowFocus( true );
                 QPEApplication::setStylusOperation( ListView1->viewport(), QPEApplication::RightOnHold);
 
                 TabWidget->insertTab( tab, tr( "Files" ) );
 
                         ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
                 tab_3 = new QWidget( TabWidget, "tab_3" );
                 QGridLayout *glayout3 = new QGridLayout( tab_3 );
                 glayout3->setSpacing( 2);
                 glayout3->setMargin( 2);
                         ////////////////////////////////////
                 sampleGroup = new QGroupBox( tab_3, "samplegroup" );
                 sampleGroup->setTitle( tr( "Sample Rate" ) );
                 sampleGroup->setFixedSize( 95,50);
 
                 sampleRateComboBox = new QComboBox( false, sampleGroup, "SampleRateComboBox" );
                 sampleRateComboBox->setGeometry( QRect( 10, 20, 80, 25 ) );
 //#ifndef QT_QWS_EBX
                 QString s;
                 int z = 0;
                 while( deviceSampleRates[z] != -1) {
                                 sampleRateComboBox->insertItem( s.setNum( deviceSampleRates[z], 10));
                                 z++;
                 }
 
 
                 glayout3->addMultiCellWidget(  sampleGroup, 0, 0, 0, 0);
 
                 sizeGroup= new QGroupBox( tab_3, "sizeGroup" );
                 sizeGroup->setTitle( tr( "Limit Size" ) );
                 sizeGroup->setFixedSize( 80, 50);
 
                 sizeLimitCombo = new QComboBox( false, sizeGroup, "sizeLimitCombo" );
                 sizeLimitCombo ->setGeometry( QRect( 5, 20, 70, 25 ) );
                 sizeLimitCombo->insertItem(tr("Unlimited"));
 
                 for(int i=1;i<13; i++) {
                                 sizeLimitCombo->insertItem( QString::number( i * 5));
                 }
 
 
                 glayout3->addMultiCellWidget(  sizeGroup, 0, 0, 1, 1);
                 dirGroup = new QGroupBox( tab_3, "dirGroup" );
                 dirGroup->setTitle( tr( "File Directory" ) );
                 dirGroup->setFixedSize( 130, 50);
 
                 directoryComboBox = new QComboBox( false, dirGroup, "dirGroup" );
                 directoryComboBox->setGeometry( QRect( 10, 15, 115, 25 ) );
 
                 glayout3->addMultiCellWidget(  dirGroup, 1, 1, 0, 0);
 
                 bitGroup = new QGroupBox( tab_3, "bitGroup" );
                 bitGroup->setTitle( tr( "Bit Depth" ) );
                 bitGroup->setFixedSize( 65, 50);
 
                 bitRateComboBox = new QComboBox( false, bitGroup, "BitRateComboBox" );
 
                 z = 0;
                 while( deviceBitRates[z] != -1) {
                                 bitRateComboBox->insertItem( s.setNum( deviceBitRates[z], 10) );
                                 z++;
                 }
 
                 bitRateComboBox->setGeometry( QRect( 5, 20, 50, 25 ) );
 
                 glayout3->addMultiCellWidget(  bitGroup, 1, 1, 1, 1);
 
                 compressionCheckBox = new QCheckBox ( tr("Wave Compression (smaller files)"), tab_3 );
 
                 autoMuteCheckBox = new QCheckBox ( tr("Auto Mute"), tab_3 );
                 stereoCheckBox = new QCheckBox ( tr("Stereo Channels"), tab_3 );
 
                 glayout3->addMultiCellWidget( compressionCheckBox, 2, 2, 0, 3);
                 glayout3->addMultiCellWidget( autoMuteCheckBox, 3, 3, 0, 0);
                 glayout3->addMultiCellWidget( stereoCheckBox, 3, 3, 1, 1);
 
                 tab_5 = new QWidget( TabWidget, "tab_5" );
 
                 QHBoxLayout *Layout19a;
                 Layout19a = new QHBoxLayout( tab_5);
                 Layout19a->setSpacing( 2 );
                 Layout19a->setMargin( 0 );
 
                 Layout15 = new QVBoxLayout( this);
                 Layout15->setSpacing( 2 );
                 Layout15->setMargin( 0 );
 
                 Layout15b = new QVBoxLayout( this);
                 Layout15b->setSpacing( 2 );
                 Layout15b->setMargin( 0 );
 
                 TextLabel2 = new QLabel( tab_5, "InputLabel" );
                 TextLabel2->setText( tr( "In"));
                 TextLabel2->setFixedWidth( 35);
                 Layout15->addWidget( TextLabel2 );
 
                 TextLabel3 = new QLabel( tab_5, "OutputLabel" );
                 TextLabel3->setText( tr( "Out" ) );
                 Layout15b->addWidget( TextLabel3 );
 
                 InputSlider = new QSlider( -100, 0, 10, 0, QSlider::Vertical, tab_5, (const char *) "InputSlider" );
                 InputSlider->setTickmarks( QSlider::Both);
                 Layout15->addWidget( InputSlider);
 
                 OutputSlider = new QSlider( -100,0,10,0, QSlider::Vertical,tab_5,(const char *) "OutputSlider" );
                 OutputSlider->setTickmarks( QSlider::Both);
 
                 Layout15b->addWidget( OutputSlider );
 
                 outMuteCheckBox = new QCheckBox ( tr("mute"), tab_5 );
                 Layout15->addWidget( outMuteCheckBox );
 
                 inMuteCheckBox = new QCheckBox ( tr("mute"), tab_5 );
                 inMuteCheckBox-> setFocusPolicy ( QWidget::NoFocus );
                 Layout15b->addWidget( inMuteCheckBox );
 
 
                 Layout19a->addLayout( Layout15 );
                 Layout19a->addLayout( Layout15b );
 
                 fillDirectoryCombo();
 
                 TabWidget->insertTab( tab_3, tr( "Options" ) );
 
                 TabWidget->insertTab( tab_5, tr( "Volume" ) );
 
 
                 waveform = new Waveform( this, "waveform" );
 //   waveform->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)5, (QSizePolicy::SizeType)3, waveform->sizePolicy().hasHeightForWidth() ) );
                 waveform->setMinimumSize( QSize( 0, 50 ) );
 
                 layout->addMultiCellWidget( waveform, 8, 8, 0, 7 );
                 waveform->setBackgroundColor ( black );
 }
 
 void QtRec::initIconView() {
 
                 ListView1->clear();
                 Config cfg("OpieRec");
                 cfg.setGroup("Sounds");
                 QString temp;
                 QPixmap image0( ( const char** ) image0_data );
 
                 int nFiles = cfg.readNumEntry("NumberofFiles",0);
         //      qDebug("init number of files %d", nFiles);
 
                 for(int i=1;i<= nFiles;i++) {
 
                                 QListViewItem * item;
                                 QString fileS, mediaLocation, fileDate,  filePath;
 
                                 temp.sprintf( "%d",i);
                                 temp = cfg.readEntry( temp,""); //reads currentFile
                                 filePath = cfg.readEntry( temp,""); //currentFileName
 
                                 QFileInfo info(filePath);
                                 fileDate = info.lastModified().toString();
 
                                 fileS = cfg.readEntry( filePath, "0" );// file length in seconds
                                 mediaLocation = getStorage( filePath);
                                 if( info.exists()) {
                                                 item = new QListViewItem( ListView1, temp,  fileS,  mediaLocation, fileDate);
                                                 item->setPixmap( 0, image0);
                                                 if( currentFileName == filePath)
                                                                 ListView1->setSelected( item, true);
                                 }
                 }
 }
 
 void QtRec::initConnections() {
                 connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
 
                 connect( toBeginningButton, SIGNAL( pressed()),
                                                  this, SLOT( rewindPressed() ));
                 connect( toBeginningButton, SIGNAL( released()),
                                                  this, SLOT( rewindReleased() ));
                 connect( toEndButton, SIGNAL( pressed()),
                                                  this, SLOT( FastforwardPressed() ));
                 connect( toEndButton, SIGNAL( released()),
                                                  this, SLOT( FastforwardReleased() ));
                 connect( deleteSoundButton, SIGNAL(released()),
                                                  this, SLOT( deleteSound() ));
                 connect( Stop_PushButton, SIGNAL(released()),
                                                  this, SLOT( doPlayBtn() ));
                 connect( Rec_PushButton, SIGNAL(released()),
                                                  this, SLOT( newSound() ) );
                 connect( TabWidget, SIGNAL( currentChanged(QWidget*)),
                                                  this, SLOT(thisTab(QWidget*) ));
                 connect( OutputSlider, SIGNAL(sliderReleased()),
                                                  this, SLOT( changedOutVolume()) );
                 connect( InputSlider, SIGNAL(sliderReleased()),
                                                  this, SLOT( changedInVolume()) );
 
                 connect( sampleRateComboBox, SIGNAL(activated(int)),
                                                  this, SLOT( changesamplerateCombo(int)) );
                 connect( bitRateComboBox, SIGNAL(activated(int)),
                                                  this, SLOT( changebitrateCombo(int)) );
 
                 connect( directoryComboBox, SIGNAL(activated(int)),
                                                  this, SLOT( changeDirCombo(int)) );
                 connect( sizeLimitCombo, SIGNAL(activated(int)),
                                                  this, SLOT( changeSizeLimitCombo(int)) );
 
                 connect( stereoCheckBox, SIGNAL(toggled(bool)),
                                                  this, SLOT( changeStereoCheck(bool)) );
    
                 connect( outMuteCheckBox, SIGNAL(toggled(bool)),
                                                  this, SLOT( doVolMuting(bool)) );
                 connect( inMuteCheckBox , SIGNAL(toggled(bool)),
                                                  this, SLOT( doMicMuting(bool)) );
 
                 connect( ListView1,SIGNAL(doubleClicked(QListViewItem*)),
                                                  this,SLOT( itClick(QListViewItem*)));
                 connect( ListView1, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int)),
                                                  this,SLOT( listPressed(int,QListViewItem*,const QPoint&,int)) );
                 connect( timeSlider, SIGNAL( sliderMoved(int)),
                                                  this, SLOT( changeTimeSlider(int) ));
                 connect( timeSlider, SIGNAL( sliderPressed()),
                                                  this, SLOT( timeSliderPressed() ));
                 connect( timeSlider, SIGNAL( sliderReleased()),
                                                  this, SLOT( timeSliderReleased() ));
                 connect( compressionCheckBox, SIGNAL( toggled(bool)),
                                                  this, SLOT( compressionSelected(bool)));
                 connect( autoMuteCheckBox, SIGNAL( toggled(bool)),
                                                  this, SLOT( slotAutoMute(bool)));
 }
 
 void QtRec::initConfig() {
                 int index, fred, i;
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
 
                 index = cfg.readNumEntry("samplerate",22050);
                 bool ok;
 
                 for(int ws=0;ws<sampleRateComboBox->count();ws++) {
                                 fred = sampleRateComboBox->text(ws).toInt(&ok, 10);
                                 if( index == fred) {
                                                 filePara.sampleRate  = fred;
                                                 sampleRateComboBox->setCurrentItem(ws);
                                 }
                 }
 
                 i = cfg.readNumEntry("bitrate",16);
                 if(i == 16)
                                 bitRateComboBox->setCurrentItem( 1);
                         elseif(i == 24)
                                 bitRateComboBox->setCurrentItem( 2);
                         elseif(i == 32)
                                 bitRateComboBox->setCurrentItem( 3);
                 else
                                 bitRateComboBox->setCurrentItem( 0);
 
                 filePara.resolution = i;
 
                 i = cfg.readNumEntry("sizeLimit", 5 );
                 QString temp;
                 sizeLimitCombo->setCurrentItem((i/5));
 
                 stereoCheckBox->setChecked( cfg.readBoolEntry("stereo", 1));
                 if( stereoCheckBox->isChecked()) {
                                 filePara.channels = 2;
                 } else {
                                 filePara.channels = 1;
                 }
 
                 compressionCheckBox->setChecked( cfg.readBoolEntry("wavCompression",1));
                 if( compressionCheckBox->isChecked()) {
                                 bitRateComboBox->setEnabled(false);
                                 bitRateComboBox->setCurrentItem(0);
                                 filePara.resolution=16;
                 }
 
                 autoMuteCheckBox->setChecked( cfg.readBoolEntry("useAutoMute",0));
                 if( autoMuteCheckBox->isChecked())
                                 slotAutoMute(true);
                 else
                                 slotAutoMute(false);
 
                 Config cofg( "qpe");
                 cofg.setGroup( "Volume");
                 outMuteCheckBox->setChecked( cofg.readBoolEntry( "Mute",0));
                 inMuteCheckBox->setChecked( cofg.readBoolEntry( "MicMute",0));
 }
 
 void QtRec::stop() {
                 qWarning("STOP");
                 setRecordButton(false);
 
                 if( !recording)
                                 endPlaying();
                 else
                                 endRecording();
                 timeSlider->setValue(0);
 }
 
 void QtRec::doPlayBtn() {
 
                 if(!stopped) {
                                 playLabel2->setText(tr("Play"));
                                 stop();
                 } else {
                                 if(ListView1->currentItem() == 0) return;
                                 playLabel2->setText(tr("Stop"));
                                 currentFile = ListView1->currentItem()->text(0);
                                 start();
                 }
 }
 
 void QtRec::start() { //play
                 if( stopped) {
                                 QPixmap image3( ( const char** ) image3_data );
                                 Stop_PushButton->setPixmap( image3 );
                                 Stop_PushButton->setDown( true);
                                 stopped = false;
                                 paused = false;
                                 secCount = 1;
 
                                 if( openPlayFile())
                                                 if( setupAudio( false))  //recording is false
                                                                 doPlay();
                 }
 }
 
 bool QtRec::rec() { //record
                 QString timeString;
                 timeString.sprintf("%.0f",  0.0);
                 timeLabel->setText( timeString+ " seconds");
                 if(!stopped) {
                                 monitoring = true;
                                 return false;
                 } else {
                                 secCount = 1;
                                 playLabel2->setText(tr("Stop"));
                                 monitoring = false;
                                 setRecordButton( true);
 
                                 if( setupAudio( true))
                                                 if(setUpFile())  {
                                                                 int fileSize = 0;
                                                                 Config cfg("OpieRec");
                                                                 cfg.setGroup("Settings");
 //             qDebug( "<<<<<<<Device bits %d, device rate %d, device channels %d",
 //                     soundDevice->getDeviceBits(),
 //                     soundDevice->getDeviceRate(),
 //                     soundDevice->getDeviceChannels());
 
                                                                         //filePara.sampleRate = cfg.readNumEntry("samplerate", 22050);
 //             qDebug("sample rate is %d", filePara.sampleRate);
                                                                 filePara.SecondsToRecord = getCurrentSizeLimit();
 
 //             qDebug("size limit %d sec", filePara.SecondsToRecord);
                                                                 int diskSize = checkDiskSpace( (const QString &) wavFile->trackName());
 
                                                                 if( filePara.SecondsToRecord == 0) {
                                                                                 fileSize = diskSize;
                                                                 } else if( filePara.format == WAVE_FORMAT_PCM) {
 //                qDebug("WAVE_FORMAT_PCM");
                                                                                 fileSize = (filePara.SecondsToRecord ) * filePara.channels
                                                                                                 * filePara.sampleRate * ( filePara.resolution / 8) + 1000;
                                                                 } else {
 //                qDebug("WAVE_FORMAT_DVI_ADPCM");
                                                                                 fileSize = ((filePara.SecondsToRecord) * filePara.channels
                                                                                                                                 * filePara.sampleRate * ( filePara.resolution / 8) ) / 4 + 250;
                                                                 }
 
                                                                 filePara.samplesToRecord = fileSize;
                                                                 qDebug("filesize should be %d, bits %d, rate %d",
                                                                                          filePara.samplesToRecord, filePara.resolution, filePara.sampleRate);
                                                                 if( paused) {
                                                                                 paused = false;
                                                                 }
                                                                         //                  else {
                                                                 qDebug("Setting timeslider %d", filePara.samplesToRecord);
                                                                         //           if(fileSize != 0)
                                                                 timeSlider->setRange(0, filePara.samplesToRecord);
                                                                         //                  }
 
                                                                 if( diskSize < fileSize/1024) {
                                                                                 QMessageBox::warning(this,
                                                                                                                                                                  tr("Low Disk Space"),
                                                                                                                                                                  tr("You are running low of\nrecording space\n"
                                                                                                                                                                                 "or a card isn't being recognized"));
                                                                                 stopped = true; //we need to be stopped
                                                                                 stop();
                                                                 } else {
                                                                                 QString msg;
                                                                                 msg.sprintf("%d, %d, %d", filePara.sampleRate, filePara.channels, filePara.resolution);
 #ifdef DEV_VERSION
                                                                                 setCaption( msg);
 #endif
                                                                                 filePara.fileName=currentFile.latin1();
                                                                                 qDebug("Start recording thread");
                                                                                 stopped = false;
 
 #ifdef THREADED
                                                                                 pthread_t thread1;
                                                                                 pthread_create( &thread1, NULL, (void * (*)(void *))quickRec, NULL/* &*/);
 #endif
                                                                                 toBeginningButton->setEnabled( false);
                                                                                 toEndButton->setEnabled( false);
 
                                                                                 startTimer(1000);
 #ifndef THREADED
                                                                                 quickRec();
 #endif
                                                                 }
                                                 } //end setUpFile
                 } //end setupAudio
                 return true;
 }
 /*
   This happens when a tab is selected*/
 void QtRec::thisTab(QWidget* widg) {
                 if(widg != NULL) {
                                 int index = TabWidget->currentPageIndex();
 
                                 if(index == 0) { //file page
                                 }
 
                                 if(index == 1) { //control page
                                                 fillDirectoryCombo();
 //       soundDevice->getOutVol();
 //       soundDevice->getInVol();
                                 }
 
                                 if( index==2) { //help page
                                 }
       
                                 qApp->processEvents();
                                 update();
                 }
 }
 
 void QtRec::getOutVol( ) {
                 filePara.outVol = soundDevice->getOutVolume();
 //   qDebug("out vol %d", filePara.outVol);
                 OutputSlider->setValue( -filePara.outVol);
 }
 
 void QtRec::getInVol() {
                 filePara.inVol = soundDevice->getInVolume();
 //    qDebug("in vol %d", filePara.inVol);
                 InputSlider->setValue( -filePara.inVol);
 }
 
 void QtRec::changedOutVolume() {
                 soundDevice->changedOutVolume( -OutputSlider->value());
 }
 
 void QtRec::changedInVolume( ) {
                 soundDevice->changedInVolume( -InputSlider->value());
 }
 
 
 bool QtRec::setupAudio( bool b) {
                 bool ok;
                 int  sampleformat, stereo, flags;
                 QString dspString, mixerString;
 
                 filePara.resolution = bitRateComboBox->currentText().toInt( &ok,10);  //16
 
                 if( !b) {
 // we want to play
 #ifdef PDAUDIO //ALSA
                                 if( filePara.resolution == 16 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = SND_PCM_FORMAT_S16;
                                                 filePara.resolution = 16;
                                 } else if( filePara.resolution == 24 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = SND_PCM_FORMAT_S24;
                                                 filePara.resolution = 24;
                                 } else if( filePara.resolution == 32 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = SND_PCM_FORMAT_S32;
                                                 filePara.resolution = 32;
                                 } else {
                                                 sampleformat = SND_PCM_FORMAT_U8;
                                                 filePara.resolution = 8;
                                 }
 #else
 // we want to play
                                 if( filePara.resolution == 16 || compressionCheckBox->isChecked() ) {
                                                 sampleformat = AFMT_S16_LE;
                                                 filePara.resolution = 16;
                                 } else {
                                                 sampleformat = AFMT_U8;
                                                 filePara.resolution = 8;
                                 }
 #endif
                         
                                 stereo = filePara.channels;
                                 flags = O_WRONLY;
                                 Config hwcfg("OpieRec");
                                 hwcfg.setGroup("Hardware");
                                 dspString = hwcfg.readEntry( "Audio", DSPSTROUT);
                                 mixerString = hwcfg.readEntry( "Mixer", DSPSTRMIXEROUT);
                                 recording = false;
                 } else { // we want to record
 
 #ifdef PDAUDIO //ALSA
                                 if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "16")
                                                 sampleformat = SND_PCM_FORMAT_S16;
                                 else if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "24")
                                                 sampleformat = SND_PCM_FORMAT_S24;
                                 else if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "32")
                                                 sampleformat = SND_PCM_FORMAT_S32;
                                 else
                                                 sampleformat = SND_PCM_FORMAT_U8;
 
 #else
                                 if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "16")
                                                 sampleformat = AFMT_S16_LE;
                                 else
                                                 sampleformat = AFMT_U8;
 
                                 if( !compressionCheckBox->isChecked()) {
                                                 filePara.format = WAVE_FORMAT_PCM;
 //          qDebug("WAVE_FORMAT_PCM");
                                 }  else {
                                                 filePara.format = WAVE_FORMAT_DVI_ADPCM;
                                                 sampleformat = AFMT_S16_LE;
 //          qDebug("WAVE_FORMAT_DVI_ADPCM");
                                 }
 #endif
                         
                                 stereo = filePara.channels;
 //        filePara.sampleRate = sampleRateComboBox->currentText().toInt( &ok,10);//44100;
                                 flags= O_RDWR;
 //        flags= O_RDONLY;
                                 Config hwcfg("OpieRec");
                                 hwcfg.setGroup("Hardware");
                                 dspString = hwcfg.readEntry( "Audio", DSPSTRIN);
                                 mixerString = hwcfg.readEntry( "Mixer", DSPSTRMIXERIN);
                                 recording = true;
                 }
 
                         // if(soundDevice) delete soundDevice;
                 qDebug("<<<<<<<<<<<<<<<<<<<open dsp %d %d %d", filePara.sampleRate, filePara.channels, sampleformat);
                 qWarning("change waveform settings");
                 waveform->changeSettings( filePara.sampleRate, filePara.channels );
 
                 soundDevice = new Device( this, dspString, mixerString, b);
 //    soundDevice->openDsp();
                 soundDevice->reset();
 
                 qDebug("device has been made %d", soundDevice->sd);
 
                         //////////////////         <<<<<<<<<<<<>>>>>>>>>>>>
                 soundDevice->setDeviceFormat( sampleformat);
                 soundDevice->setDeviceChannels( filePara.channels);
                 soundDevice->setDeviceRate( filePara.sampleRate);
                 soundDevice->getDeviceFragSize();
 #ifdef QT_QWS_EBX
                 int frag = FRAGSIZE;
                 soundDevice->setFragSize( frag);
                 soundDevice->getDeviceFragSize();
 #endif
                         /////////////////
                 filePara.sd = soundDevice->sd;
 
                 if ( filePara.sd == -1) {
 
                                 monitoring = false;
                                 stopped = true;
                                 update();
                                 setCaption( tr( "OpieRecord " )+ QString::number(VERSION) );
                                 return false;
                 }
                 if(autoMute)
                                 doMute(false);
 
                 return true;
 }
 
 
 bool QtRec::setUpFile() { //setup file for recording
 //    qDebug("Setting up wavfile");
 //  if(wavFile) delete wavFile;
                 wavFile = new WavFile( this, (const QString &)"",
                                                                                                          true,
                                                                                                          filePara.sampleRate,
                                                                                                          filePara.channels,
                                                                                                          filePara.resolution,
                                                                                                          filePara.format);
 
                 filePara.fd = wavFile->wavHandle();
                 if(filePara.fd == -1) {
                                 return false;
                 } else {
 //      filePara.channels=1;
                 }
                 return true;
 }
 
 /// <<<<<<<<<<<<<<<<  PLAY >>>>>>>>>>>>>>>>>>>
 bool QtRec::doPlay() {
 
                 if( !paused) {
                                 total = 0;
                                 filePara.numberOfRecordedSeconds = 0;
                 } else {
                                 paused = false;
                                 secCount = (int)filePara.numberOfRecordedSeconds;
                 }
                 playing = true;
                 stopped = false;
                 recording = false;
 
                 QString num;
                 qDebug( "Play number of samples %d", filePara.numberSamples);
 
 //   timeSlider->setRange( 0, filePara.numberSamples);
 
                 timeString.sprintf("%f",  filePara.numberOfRecordedSeconds);
                 timeLabel->setText( timeString+ tr(" seconds"));
 
                 QString msg;
                 msg.sprintf("%d, %d, %d",
                                                                 filePara.sampleRate,
                                                                 filePara.channels,
                                                                 filePara.resolution);
 #ifdef DEV_VERSION
                 setCaption( msg);
 #endif
 
                 startTimer( 1000);
 #ifdef THREADED
                 pthread_t thread2;
                 pthread_create( &thread2, NULL, (void * (*)(void *))playIt, NULL/* &*/);
 #endif
                  
                 toBeginningButton->setEnabled( false);
                 toEndButton->setEnabled( false);
 #ifndef  THREADED
                 playIt();
 #endif
                 return true;
 }
 
 
 void QtRec::changebitrateCombo(int i) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 int bits = 0;
                 if( i == 1) { bits = 16; }
                 else if( i == 2) { bits = 24; }
                 else if( i == 3) { bits = 32; }
                 else { bits=8; }
                 cfg.writeEntry("bitrate", bits);
                 filePara.resolution = bits;
                 cfg.write();
 }
 
 void QtRec::changesamplerateCombo(int i) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 int rate=0;
                 bool ok;
                 rate = sampleRateComboBox->text(i).toInt(&ok, 10);
                 cfg.writeEntry( "samplerate",rate);
                 filePara.sampleRate=rate;
                 qDebug( "Change sample rate %d", rate);
                 cfg.write();
 }
 
 
 void QtRec::changeDirCombo(int index) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 QString sName = directoryComboBox->text(index);
 
                 StorageInfo storageInfo;
                 const QList<FileSystem> &fs = storageInfo.fileSystems();
                 QListIterator<FileSystem> it ( fs );
                 QString storage;
                 for( ; it.current(); ++it ){
                                 if( sName == (*it)->name()+" "+  (*it)->path() ||
                                                 (*it)->name() == sName ) {
                                                 const QString path = (*it)->path();
                                                 recDir = path;
                                                 cfg.writeEntry("directory", recDir);
                                                 qDebug("new rec dir "+recDir);
                                 }
                 }
                 cfg.write();
 }
 
 
 void QtRec::changeSizeLimitCombo(int) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 cfg.writeEntry("sizeLimit", getCurrentSizeLimit() );
                 cfg.write();
 }
 
 void QtRec::newSound() {
                 if( !rec()) {
                                 endRecording();
                                 deleteSound();
                 }
 }
 
 void QtRec::itClick(QListViewItem *item) {
                 currentFile = item->text(0);
                 setCaption("OpieRecord  "+currentFile);
 }
 
 void QtRec::deleteSound() {
                 Config cfg("OpieRec");
                 cfg.setGroup("Sounds");
                 if( ListView1->currentItem() == NULL)
                                 return;
 #ifndef DEV_VERSION
                 switch ( QMessageBox::warning(this,tr("Delete"),
                                                                                                                                         tr("Do you really want to <font size=+2><B>DELETE</B></font>\nthe selected file?"),
                                                                                                                                         tr("Yes"),tr("No"),0,1,1) ) {
                         case 0:
 #endif
                         {
                                         QString file = ListView1->currentItem()->text(0);
                                         QString fileName;
                                         fileName = cfg.readEntry( file, "");
                                         QFile f( fileName);
                                         if( f.exists())
                                                         if( !f.remove())
                                                                         QMessageBox::message( tr("Error"), tr("Could not remove file."));
 
                                         int nFiles = cfg.readNumEntry( "NumberofFiles",0);
                                         bool found = false;
                                         for(int i=0;i<nFiles+1;i++) {
 
                                                         if( cfg.readEntry( QString::number(i),"").find( file,0,true) != -1) {
                                                                         found = true;
                                                                         cfg.writeEntry( QString::number(i), cfg.readEntry( QString::number(i+1),""));
                                                         }
                                                         if(found)
                                                                         cfg.writeEntry( QString::number(i), cfg.readEntry( QString::number(i+1),""));
                                         }
 
                                         cfg.removeEntry( cfg.readEntry( file));
                                         cfg.removeEntry( file);
                                         cfg.writeEntry( "NumberofFiles", nFiles-1);
                                         cfg.write();
 
                                         ListView1->takeItem( ListView1->currentItem() );
                                         delete ListView1->currentItem();
 
                                         ListView1->clear();
                                         ListView1->setSelected( ListView1->firstChild(), true);
                                         initIconView();
                                         update();
                         }
 #ifndef DEV_VERSION
                 };
 #endif
                 setCaption( tr( "OpieRecord " ) + QString::number(VERSION) );
 
 }
 
 void QtRec::keyPressEvent( QKeyEvent *e) {
 
                 switch ( e->key() ) {
                                         //  case Key_F1:
                                         //     if(stopped && !recording)
                                         //       newSound();
                                         //     else
                                         //       stop();
                                         //    break;
                                         //   case Key_F2: {
                                         //     if( !e->isAutoRepeat())
                                         //     rewindPressed();
                                         //   }
                                         //     break;
                                         //   case Key_F3: {
                                         //     if( !e->isAutoRepeat())
                                         //     FastforwardPressed();
                                         //   }
                                         //     break;
 
                                         ////////////////////////////// Zaurus keys
                         case Key_F9: //activity
                                         break;
                         case Key_F10: //contacts
                                         break;
                         case Key_F11: //menu
                                         break;
                         case Key_F12: //home
                                         break;
                         case Key_F13: //mail
                                         break;
                         case Key_Space:
                                         break;
                         case Key_Delete:
                                         break;
                         case Key_Up:
                                                 //    stop();
                                         break;
                         case Key_Down:
                                                 //    newSound();
                                         break;
                         case Key_Left: {
                                         qDebug("rewinding");
                                         if( !e->isAutoRepeat())
                                                         rewindPressed();
                         }
                                         break;
                         case Key_Right: {
                                         if( !e->isAutoRepeat())
                                                         FastforwardPressed();
                         }
                                         break;
                 }
 }
 
 void  QtRec::keyReleaseEvent( QKeyEvent *e) {
                 switch ( e->key() ) {
                                         //   case Key_F1:
                                         //      if(stopped && !recording)
                                         //        newSound();
                                         //      else
                                         //        stop();
                                         //     break;
                                         //   case Key_F2:
                                         //     rewindReleased();
                                         //     break;
                                         //   case Key_F3:
                                         //     FastforwardReleased();
                                         //     break;
 
                                         ////////////////////////////// Zaurus keys
                         case Key_F9: //activity
                                         break;
                         case Key_F10: //contacts
                                         break;
                         case Key_F11: //menu
                                         break;
                         case Key_F12: //home
                                         if(stopped)
                                                         doPlayBtn();
                                         else
                                                         stop();
                                         break;
                         case Key_F13: //mail
                                         break;
                         case Key_Space:
                                         if(stopped && !recording)
                                                         newSound();
                                         else
                                                         stop();
                                         break;
                         case Key_Delete:
                                         deleteSound();
                                         break;
                         case Key_Up:
                                                 //      stop();
                                         qDebug("Up");
                                         break;
                         case Key_Down:
                                                 //      start();
                                                 //      qDebug("Down");
                                                 //    newSound();
                                         break;
                         case Key_Left:
                                         qDebug("Left");
                                         rewindReleased();
                                         break;
                         case Key_Right:
                                         qDebug("Right");
                                         FastforwardReleased();
                                         break;
                 }
 }
 
 void QtRec::endRecording() {
                 monitoring = false;
                 recording = false;
                 stopped = true;
                 waveform->reset();
                 setRecordButton( false);
 
                 toBeginningButton->setEnabled( true);
                 toEndButton->setEnabled( true);
 
                 killTimers();
 
                 if(autoMute)
                                 doMute( true);
 
                 soundDevice->closeDevice( true);
 
                 if( wavFile->track.isOpen()) {
                                 wavFile->adjustHeaders( filePara.fd, filePara.numberSamples);
                                         //    soundDevice->sd=-1;
                                 filePara.numberSamples = 0;
                                         //      filePara.sd=-1;
                                 wavFile->closeFile();
                                 filePara.fd=0;
 
                                 if( wavFile->isTempFile()) {
 // move tmp file to regular file
                                                 QString cmd;
                                                 cmd.sprintf("mv "+ wavFile->trackName() + " " + wavFile->currentFileName);
 //         qDebug("moving tmp file to "+currentFileName);
                                                 system( cmd.latin1());
                                 }
       
                                 qDebug("Just moved " + wavFile->currentFileName);
                                 Config cfg("OpieRec");
                                 cfg.setGroup("Sounds");
 
                                 int nFiles = cfg.readNumEntry( "NumberofFiles",0);
 
                                 currentFile = QFileInfo( wavFile->currentFileName).fileName();
                                 currentFile = currentFile.left( currentFile.length() - 4);
 
                                 cfg.writeEntry( "NumberofFiles", nFiles + 1);
                                 cfg.writeEntry( QString::number( nFiles + 1), currentFile);
                                 cfg.writeEntry( currentFile, wavFile->currentFileName);
 
                                 QString time;
                                 time.sprintf("%.2f", filePara.numberOfRecordedSeconds);
                                 cfg.writeEntry( wavFile->currentFileName, time );
 //       qDebug("writing config numberOfRecordedSeconds "+time);
 
                                 cfg.write();
                                 qDebug("finished recording");
                                 timeLabel->setText("");
                 }
 
                 if(soundDevice) delete soundDevice;
 
                 timeSlider->setValue(0);
                 initIconView();
                 selectItemByName( currentFile);
 }
 
 void QtRec::endPlaying() {
                 monitoring = false;
                 recording = false;
                 playing = false;
                 stopped = true;
                 waveform->reset();
 //   errorStop();
 //    qDebug("end playing");
                 setRecordButton( false);
 
                 toBeginningButton->setEnabled( true);
                 toEndButton->setEnabled( true);
 
                 if(autoMute)
                                 doMute( true);
 
                 soundDevice->closeDevice( false);
                 soundDevice->sd = -1;
                         //  if(soundDevice) delete soundDevice;
 //    qDebug("file and sound device closed");
                 timeLabel->setText("");
                 total = 0;
                 filePara.numberSamples = 0;
                 filePara.sd = -1;
 //   wavFile->closeFile();
                 filePara.fd = 0;
 //  if(wavFile) delete wavFile; //this crashes
 
 //    qDebug("track closed");
                 killTimers();
                 qWarning("reset slider");
                 timeSlider->setValue(0);
 
                 if(soundDevice) delete soundDevice;
 
 }
 
 bool QtRec::openPlayFile() {
 
                 qApp->processEvents();
                 if( currentFile.isEmpty()) {
                                 QMessageBox::message(tr("Opierec"),tr("Please select file to  play"));
                                 endPlaying();
                                 return false;
                 }
                 QString currentFileName;
                 Config cfg("OpieRec");
                 cfg.setGroup("Sounds");
                 int nFiles = cfg.readNumEntry( "NumberofFiles", 0);
                 for(int i=0;i<nFiles+1;i++) { //look for file
                                 if( cfg.readEntry( QString::number(i),"").find( currentFile,0,true) != -1) {
                                                 currentFileName = cfg.readEntry( currentFile, "" );
                                                 qDebug("opening for play: " + currentFileName);
                                 }
                 }
                 wavFile = new WavFile(this,
                                                                                                         currentFileName,
                                                                                                         false);
                 filePara.fd = wavFile->wavHandle();
                 if(filePara.fd == -1) {
                                         //  if(!track.open(IO_ReadOnly)) {
                                 QString errorMsg = (QString)strerror(errno);
                                 monitoring = false;
                                 setCaption( tr( "OpieRecord " ) + QString::number(VERSION) );
                                 QMessageBox::message(tr("Note"), tr("Could not open audio file.\n")
                                                                                                                  + errorMsg + "\n" + currentFile);
                                 return false;
                 } else {
 
                                 filePara.numberSamples = wavFile->getNumberSamples();
                                 filePara.format = wavFile->getFormat();
                                 filePara.sampleRate = wavFile->getSampleRate();
                                 filePara.resolution = wavFile->getResolution();
                                 filePara.channels = wavFile->getChannels();
                                 timeSlider->setPageStep(1);
                                 monitoring = true;
 
                                 qDebug("file %d, samples %d %d", filePara.fd, filePara.numberSamples, filePara.sampleRate);
                                 int sec = (int) (( filePara.numberSamples / filePara.sampleRate) / filePara.channels) / ( filePara.channels*( filePara.resolution/8));
 
                                 qWarning("seconds %d", sec);
 
                                 timeSlider->setRange(0, filePara.numberSamples );
                 }
 
                 return true;
 }
 
 void QtRec::listPressed( int mouse, QListViewItem *item, const QPoint &, int ) {
                 if(item == NULL )
                                 return;
                 switch (mouse) {
                         case 1: {
                                         if( renameBox != 0 ) //tricky
                                                         cancelRename();
 
                                         currentFile = item->text(0);
                                         setCaption( "OpieRecord  " + currentFile);
                         }
                                         break;
                         case 2:
                                         showListMenu(item);
                                         ListView1->clearSelection();
                                         break;
                 };
 }
 
 void QtRec::showListMenu(QListViewItem * item) {
                 if(item == NULL)
                                 return;
                 QPopupMenu *m = new QPopupMenu(this);
                 m->insertItem( tr("Play"), this, SLOT( doMenuPlay() ));
                 if(Ir::supported())  m->insertItem( tr( "Send with Ir" ), this, SLOT( doBeam() ));
                 m->insertItem( tr( "Rename" ), this, SLOT( doRename() ));
                         // #if defined (QTOPIA_INTERNAL_FSLP)
                         //     m->insertItem( tr( "Properties" ), this, SLOT( doProperties() ));
                         // #endif
                 m->insertSeparator();
                 m->insertItem( tr("Delete"), this, SLOT( deleteSound() ) );
                 m->exec( QCursor::pos() );
                 qApp->processEvents();
 }
 
 void QtRec::fileBeamFinished( Ir *ir) {
                 if(ir)
                                 QMessageBox::message( tr("Ir Beam out"), tr("Ir sent.") ,tr("Ok") );
 
 }
 
 void QtRec::doBeam() {
                 qApp->processEvents();
                 if(  ListView1->currentItem() == NULL)
                                 return;
                 Ir ir;
                 if( ir.supported()) {
                                 QString file = ListView1->currentItem()->text(0);
                                 Config cfg("OpieRec");
                                 cfg.setGroup("Sounds");
 
                                 int nFiles = cfg.readNumEntry("NumberofFiles",0);
 
                                 for(int i=0;i<nFiles+1;i++) {
                                                 if( cfg.readEntry( QString::number( i),"").find( file, 0, true) != -1) {
                                                                 QString filePath = cfg.readEntry(file,"");
                                                                 Ir *file = new Ir(this, "IR");
                                                                 connect( file, SIGNAL( done(Ir*)),
                                                                                                  this, SLOT( fileBeamFinished(Ir*)));
                                                                 file->send( filePath, "OPieRec audio file\n" + filePath );
                                                 }
                                 }
                 }
 }
 
 void QtRec::doMenuPlay() {
                 qApp->processEvents();
                 currentFile = ListView1->currentItem()->text(0);
 }
 
 void QtRec::doRename() {
                 QRect r = ListView1->itemRect( ListView1->currentItem( ));
                 r = QRect( ListView1->viewportToContents( r.topLeft() ), r.size() );
                 r.setX( ListView1->contentsX() );
                 if ( r.width() > ListView1->visibleWidth() )
                                 r.setWidth( ListView1->visibleWidth() );
 
                 renameBox = new QLineEdit( ListView1->viewport(), "qt_renamebox" );
                 renameBox->setFrame(true);
 
                 renameBox->setText(  ListView1->currentItem()->text(0) );
 
                 renameBox->selectAll();
                 renameBox->installEventFilter( this );
                 ListView1->addChild( renameBox, r.x(), r.y() );
                 renameBox->resize( r.size() );
                 ListView1->viewport()->setFocusProxy( renameBox );
                 renameBox->setFocus();
                 renameBox->show();
 
 }
 
 void QtRec::okRename() {
                 qDebug(renameBox->text());
                 QString  filename = renameBox->text();
                 cancelRename();
 
                 if(  ListView1->currentItem() == NULL)
                                 return;
 
                 Config cfg("OpieRec");
                 cfg.setGroup("Sounds");
 
                 QString file = ListView1->currentItem()->text(0);
 
                 qDebug("filename is  " + filename);
 
                 int nFiles = cfg.readNumEntry("NumberofFiles",0);
 
                 for(int i=0;i<nFiles+1;i++) { //look for file
                                 if( cfg.readEntry( QString::number(i),"").find(file,0,true) != -1) {
 
                                                 QString filePath = cfg.readEntry(file,"");
 
                                                 cfg.writeEntry( QString::number(i), filename );
                                                 cfg.writeEntry( filename, filePath );
                                                 cfg.removeEntry( file);
                                                 cfg.write();
                                 }
                 }
 
                 ListView1->takeItem( ListView1->currentItem() );
                 delete ListView1->currentItem();
                 ListView1->clear();
                 initIconView();
                 update();
 }
 
 void QtRec::cancelRename() {
                 bool resetFocus = ListView1->viewport()->focusProxy() == renameBox;
                 delete renameBox;
                 renameBox = 0;
                 if ( resetFocus ) {
                                 ListView1->viewport()->setFocusProxy( ListView1 );
                                 ListView1->setFocus();
                 }
 }
 
 bool QtRec::eventFilter( QObject * o, QEvent * e ) {
                 if ( o->inherits( "QLineEdit" ) ) {
                                 if ( e->type() == QEvent::KeyPress ) {
                                                 QKeyEvent *ke = (QKeyEvent*)e;
                                                 if ( ke->key() == Key_Return ||
                                                                  ke->key() == Key_Enter ) {
                                                                 okRename();
                                                                 return true;
                                                 } else if ( ke->key() == Key_Escape ) {
                                                                 cancelRename();
                                                                 return true;
                                                 }
                                 } else if ( e->type() == QEvent::FocusOut ) {
                                                 cancelRename();
                                                 return true;
                                 }
                 }
                 return QWidget::eventFilter( o, e );
 }
 
 
 int QtRec::getCurrentSizeLimit() {
                 return  sizeLimitCombo->currentItem() * 5;
 }
 
 void QtRec::timerBreak() {
                 endPlaying();
 }
 
 void QtRec::doVolMuting(bool b) {
                 Config cfg( "qpe" );
                 cfg. setGroup( "Volume" );
                 cfg.writeEntry( "Mute",b);
                 cfg.write();
                 QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << b;
 }
 
 void QtRec::doMicMuting(bool b) {
                         //  qDebug("mic mute");
                 Config cfg( "qpe" );
                 cfg. setGroup( "Volume" );
                 cfg.writeEntry( "MicMute",b);
                 cfg.write();
                 QCopEnvelope( "QPE/System", "micChange(bool)" ) << b;
 }
 
 void QtRec::compressionSelected(bool b) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 cfg.writeEntry("wavCompression", b);
                 cfg.writeEntry("bitrate", 16);
                 filePara.resolution = 16;
                 cfg.write();
 
                 if(b) {
                                 bitRateComboBox->setEnabled( false);
                                 bitRateComboBox->setCurrentItem( 0);
                                 filePara.resolution = 16;
                 } else{
                                 bitRateComboBox->setEnabled( true);
                 }
 }
 
 long QtRec::checkDiskSpace(const QString &path) {
 
                 struct statfs fs;
 
                 if ( !statfs( path.latin1(), &fs ) ) {
 
                                 int blkSize = fs.f_bsize;
                                 int availBlks = fs.f_bavail;
 
                                 long mult = blkSize / 1024;
                                 long div = 1024 / blkSize;
 
                                 if ( !mult ) mult = 1;
                                 if ( !div ) div = 1;
 
                                 return  availBlks * mult / div;
                 }
                 return -1;
 }
 
 //   short  f_fstyp;    /* File system type */
 //   long  f_bsize;    /* Block size */
 //   long  f_frsize;   /* Fragment size */
 //   long  f_blocks;   /* Total number of blocks*/
 //   long  f_bfree;    /* Count of free blocks */
 //   long  f_files;    /* Total number of file nodes */
 //   long  f_ffree;    /* Count of free file nodes */
 //   char  f_fname[6]; /* Volumename */
 //   char  f_fpack[6]; /* Pack name */
 
 void QtRec::receive( const QCString &msg, const QByteArray & ) {
                 qDebug("Voicerecord received message "+msg);
 
 }
 
 
 ///////////////////////////// timerEvent
 void QtRec::timerEvent( QTimerEvent * ) {
 
 //    if(!recording)
 //       timeSlider->setValue( secCount);
 //     else
 //        timeSlider->setValue( filePara.numberOfRecordedSeconds);
 
                 if( stopped && playing) {
                                 stop();
                 }
 
                 if( stopped && recording ){
                                 stop();
                 }
       
                 if( recording && filePara.SecondsToRecord < secCount && filePara.SecondsToRecord != 0) {
                                 stop();
                 }
    
                 qDebug( "%d", secCount );
                 QString  timeString;
 #ifdef DEV_VERSION
                 QString msg;
                 msg.sprintf("%d, %d, %d", filePara.sampleRate, filePara.channels, filePara.resolution);
                 setCaption( msg +" ::  "+QString::number(secCount));
 #endif
 
                 timeString.sprintf("%d", secCount);
                 timeLabel->setText( timeString + " seconds");
 
                 secCount++;
 }
 
 void QtRec::changeTimeSlider(int index) {
                 if( ListView1->currentItem() == 0 || !wavFile->track.isOpen()) return;
                         //  qDebug("Slider moved to %d",index);
                 paused = true;
                 stopped = true;
 
                 sliderPos=index;
 
                 QString timeString;
                 filePara.numberOfRecordedSeconds = (float)sliderPos / (float)filePara.sampleRate * (float)2;
                 timeString.sprintf( "%.2f", filePara.numberOfRecordedSeconds);
                 secCount = (int)filePara.numberOfRecordedSeconds;
                 timeLabel->setText( timeString + tr(" seconds"));
 }
 
 void QtRec::timeSliderPressed() {
                 if( ListView1->currentItem() == 0) return;
                         //  qDebug("slider pressed");
                 paused = true;
                 stopped = true;
 }
 
 void QtRec::timeSliderReleased() {
                 if( ListView1->currentItem() == 0) return;
                 sliderPos = timeSlider->value();
 
                         //  qDebug("slider released %d", sliderPos);
                 stopped = false;
                 int newPos =  lseek( filePara.fd, sliderPos, SEEK_SET);
                 total =  newPos*4;
                 filePara.numberOfRecordedSeconds = (float)sliderPos / (float)filePara.sampleRate * (float)2;
 
                 doPlay();
 }
 
 void QtRec::rewindPressed() {
                 if( ListView1->currentItem() == 0) return;
                 if( !wavFile->track.isOpen()) {
                                 if( !openPlayFile() )
                                                 return;
                                 else
                                                 if( !setupAudio( false))
                                                                 return;
                 } else {
                                 killTimers();
                                 paused = true;
                                 stopped = true;
                                 rewindTimer->start( 50, false);
                 }
 }
 
 void QtRec::rewindTimerTimeout() {
                 int  sliderValue = timeSlider->value();
                 sliderValue = sliderValue - ( filePara.numberSamples / 100);
                         //  if(toBeginningButton->isDown())
                 timeSlider->setValue( sliderValue ) ;
                         //  qDebug("%d", sliderValue);
                 QString timeString;
                 filePara.numberOfRecordedSeconds = (float)sliderValue / (float)filePara.sampleRate * (float)2;
                 timeString.sprintf( "%.2f", filePara.numberOfRecordedSeconds);
                 timeLabel->setText( timeString+ tr(" seconds"));
 }
 
 void QtRec::rewindReleased() {
                 rewindTimer->stop();
                 if( wavFile->track.isOpen()) {
                                 sliderPos=timeSlider->value();
                                 stopped = false;
                                 int newPos =  lseek( filePara.fd, sliderPos, SEEK_SET);
                                 total =  newPos * 4;
                                         //    qDebug("rewind released %d", total);
                                 startTimer( 1000);
                                 doPlay();
                 }
 }
 
 void QtRec::FastforwardPressed() {
                 if( ListView1->currentItem() == 0) return;
                 if( !wavFile->track.isOpen())
                                 if( !openPlayFile() )
                                                 return;
                                 else
                                                 if( !setupAudio( false))
                                                                 return;
                 killTimers();
 
                 paused = true;
                 stopped = true;
                 forwardTimer->start(50, false);
 }
 
 
 void QtRec::forwardTimerTimeout() {
                 int sliderValue = timeSlider->value();
                 sliderValue = sliderValue + ( filePara.numberSamples / 100);
 
                         //  if(toEndButton->isDown())
                 timeSlider->setValue( sliderValue);
 
                 QString timeString;
                 filePara.numberOfRecordedSeconds = (float)sliderValue / (float)filePara.sampleRate * (float)2;
                 timeString.sprintf( "%.2f", filePara.numberOfRecordedSeconds);
                 timeLabel->setText( timeString+ tr(" seconds"));
 }
 
 void QtRec::FastforwardReleased() {
                 forwardTimer->stop();
                 if( wavFile->track.isOpen()) {
                                 sliderPos=timeSlider->value();
                                 stopped = false;
                                 int newPos =  lseek( filePara.fd, sliderPos, SEEK_SET);
                                 total =  newPos * 4;
                                 filePara.numberOfRecordedSeconds = (float)sliderPos / (float)filePara.sampleRate * (float)2;
                                 startTimer( 1000);
                                 doPlay();
                 }
 }
 
 
 QString QtRec::getStorage(const QString &fileName) {
 
                 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();
                                 if( fileName.find( path,0,true) != -1)
                                                 storage = name;
                                         //        const QString options = (*it)->options();
                                         //        if( name.find( tr("Internal"),0,true) == -1) {
                                         //            storageComboBox->insertItem( name +" -> "+disk);
                                         //    qDebug(name);
                 }
                 return storage;
                         //      struct mntent *me;
                         //  //     if(fileName == "/etc/mtab") {
                         //      FILE *mntfp = setmntent( fileName.latin1(), "r" );
                         //      if ( mntfp ) {
                         //          while ( (me = getmntent( mntfp )) != 0 ) {
                         //              QString filesystemType = me->mnt_type;
 
                         //          }
                         //      }
                         //      endmntent( mntfp );
 }
 
 void QtRec::setRecordButton(bool b) {
 
                 if(b) { //about to record or play
 
                                 Rec_PushButton->setDown( true);
                                 QPixmap image3( ( const char** ) image3_data );
                                 Stop_PushButton->setPixmap( image3 );
                                 if(Stop_PushButton->isDown())
                                                 Stop_PushButton->setDown( true);
                                 playLabel2->setText( tr("Stop") );
 
                 } else { //about to stop
 
                                 QPixmap image4( ( const char** ) image4_data );
                                 Stop_PushButton->setPixmap( image4);
                                 if(Stop_PushButton->isDown())
                                                 Stop_PushButton->setDown( false);
                                 playLabel2->setText( tr("Play") );
                                 if(Rec_PushButton->isDown())
                                                 Rec_PushButton->setDown( false);
                 }
 }
 
 void QtRec::fillDirectoryCombo() {
                 if( directoryComboBox->count() > 0)
                                 directoryComboBox->clear();
                 int index = 0;
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 QString dir = cfg.readEntry("directory", "/");
                 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();
                                         //    directoryComboBox->insertItem(name+" "+path);
                                 directoryComboBox->insertItem(name);
                                 if( path == dir)
                                                 directoryComboBox->setCurrentItem( index);
                                 index++;
                 }
 }
 
 void QtRec::errorStop() {
                 stopped = true;
                 wavFile->closeFile();
                 killTimers();
 }
 
 void QtRec::doMute(bool b) {
                 doVolMuting( b);
                 doMicMuting( b);
 }
 
 void QtRec::slotAutoMute(bool b) {
                 autoMute = b;
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 cfg.writeEntry("useAutoMute",b);
                 doMute( b);
                 outMuteCheckBox->setChecked( b);
                 inMuteCheckBox->setChecked( b);
 }
 
 void QtRec::selectItemByName(const QString & name) {
                 QListViewItemIterator it( ListView1 );
                 for ( ; it.current(); ++it )
                                 if( name == it.current()->text(0))
                                                 ListView1->setCurrentItem(it.current());
 }
 
 
 // long findPeak(long input ) {
 
 // // halfLife = time in seconds for output to decay to half value after an impulse
 //    static float output = 0.0;
 //    float halfLife = .0025;
 //    float vsf = .0025;
 //    float scalar = pow( 0.5, 1.0/(halfLife * filePara.sampleRate ));
 //    if( input < 0.0 )
 //       input = -input;  // Absolute value.
 //    if ( input >= output ) {
 //       // When we hit a peak, ride the peak to the top.
 //       output = input;
 //    } else {
 // // Exponential decay of output when signal is low.
 //       output = output * scalar;
 // //
 // //   When current gets close to 0.0, set current to 0.0 to prevent FP underflow
 // //   which can cause a severe performance degradation due to a flood
 // //   of interrupts.
 // //
 //       if( output < vsf ) output = 0.0;
 //    }
 
 //    return (long) output;
 // }
 
 void QtRec::changeStereoCheck(bool b) {
                 Config cfg("OpieRec");
                 cfg.setGroup("Settings");
                 int ch = 0;
                 if ( !b) { ch = 1;}
                 else { ch = 2;}
                 cfg.writeEntry("stereo", b);
                 filePara.channels = ch;
    
                 cfg.write();
 }
 
                 
diff --git a/noncore/multimedia/opierec/wavFile.cpp b/noncore/multimedia/opierec/wavFile.cpp
index 1d58bb3..35bc14d 100644
--- a/noncore/multimedia/opierec/wavFile.cpp
+++ b/noncore/multimedia/opierec/wavFile.cpp
@@ -1,312 +1,311 @@
 //wavFile.cpp
 #include "wavFile.h"
 #include "qtrec.h"
 
 #include <qmessagebox.h>
 #include <qdir.h>
 
-#include <qpe/timestring.h>
 #include <qpe/config.h>
 
 #include <errno.h>
 
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/vfs.h>
 
 #include <fcntl.h>
 #include <math.h>
 #include <mntent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 WavFile::WavFile( QObject * parent,const QString &fileName, bool makeNwFile, int sampleRate,
                   int channels, int resolution, int format )
         : QObject( parent)
 {
 //qDebug("new wave file");
     bool b =  makeNwFile;
     wavSampleRate=sampleRate;
     wavFormat=format;
     wavChannels=channels;
     wavResolution=resolution;
     useTmpFile=false;
     if( b) {
         newFile();
     } else {
         openFile(fileName);
     }
 }
 
 bool WavFile::newFile() {
 
 //  qDebug("Set up new file");
   Config cfg("OpieRec");
   cfg.setGroup("Settings");
 
   currentFileName=cfg.readEntry("directory",QDir::homeDirPath());
   QString date;
   QDateTime dt = QDateTime::currentDateTime();
   date = dt.toString();//TimeString::dateString( QDateTime::currentDateTime(),false,true);
   date.replace(QRegExp("'"),"");
   date.replace(QRegExp(" "),"_");
   date.replace(QRegExp(":"),".");
   date.replace(QRegExp(","),"");
 
   QString currentFile=date;
   if(currentFileName.right(1).find("/",0,true) == -1)
     currentFileName += "/" + date;
   else
     currentFileName += date;
   currentFileName+=".wav";
 
 //  qDebug("set up file for recording: "+currentFileName);
   char pointer[] = "/tmp/opierec-XXXXXX";
   int fd = 0;
 
   if( currentFileName.find("/mnt",0,true) == -1
       && currentFileName.find("/tmp",0,true) == -1 ) {
     // if destination file is most likely in flash (assuming jffs2)
     // we have to write to a different filesystem first
         
     useTmpFile = true;
     if(( fd = mkstemp( pointer)) < 0 ) {
        perror("mkstemp failed");
        return false;
     }
     
 //    qDebug("Opening tmp file %s",pointer);
     track.setName( pointer);
 
   } else { //just use regular file.. no moving
       
     useTmpFile = false;
     track.setName( currentFileName);
   }
   if(!track.open( IO_ReadWrite | IO_Truncate)) {
     QString errorMsg=(QString)strerror(errno);
     qDebug(errorMsg);
     QMessageBox::message("Note", "Error opening file.\n" +errorMsg);
   
     return false;
   } else {
     setWavHeader( track.handle() , &hdr);
   }
 return true;
 }
 
 WavFile::~WavFile() {
 
     closeFile();
 }
 
 void WavFile::closeFile() {
     if(track.isOpen()) 
         track.close();
 }
 
 int WavFile::openFile(const QString &currentFileName) {
 //    qDebug("open play file "+currentFileName);
     closeFile();
     
   track.setName(currentFileName);
 
   if(!track.open(IO_ReadOnly)) {
     QString errorMsg=(QString)strerror(errno);
     qDebug("<<<<<<<<<<< "+errorMsg+currentFileName);
     QMessageBox::message("Note", "Error opening file.\n" +errorMsg);
     return -1;
   } else {
     parseWavHeader( track.handle());
   }
   return track.handle();
 }
                   
 bool WavFile::setWavHeader(int fd, wavhdr *hdr) {
 
   strncpy((*hdr).riffID, "RIFF", 4); // RIFF
   strncpy((*hdr).wavID, "WAVE", 4); //WAVE
   strncpy((*hdr).fmtID, "fmt ", 4); // fmt
   (*hdr).fmtLen = 16; // format length = 16
 
   if( wavFormat == WAVE_FORMAT_PCM) {
     (*hdr).fmtTag = 1; // PCM
 //    qDebug("set header  WAVE_FORMAT_PCM");
   }
   else {
     (*hdr).fmtTag = WAVE_FORMAT_DVI_ADPCM; //intel ADPCM
  //    qDebug("set header  WAVE_FORMAT_DVI_ADPCM");
   }
 
   //  (*hdr).nChannels = 1;//filePara.channels;// ? 2 : 1*/; // channels
   (*hdr).nChannels = wavChannels;// ? 2 : 1*/; // channels
 
   (*hdr).sampleRate = wavSampleRate; //samples per second
   (*hdr).avgBytesPerSec = (wavSampleRate)*( wavChannels*(wavResolution/8)); // bytes per second
   (*hdr).nBlockAlign = wavChannels*( wavResolution/8); //block align
   (*hdr).bitsPerSample = wavResolution; //bits per sample 8, or 16
 
   strncpy((*hdr).dataID, "data", 4);
 
   write( fd,hdr, sizeof(*hdr));
    qDebug("writing header: bitrate%d, samplerate %d,  channels %d",
           wavResolution, wavSampleRate, wavChannels);
   return true;
 }
 
 bool WavFile::adjustHeaders(int fd, int total) {
   lseek(fd, 4, SEEK_SET);
   int i = total + 36;
   write( fd, &i, sizeof(i));
   lseek( fd, 40, SEEK_SET);
   write( fd, &total, sizeof(total));
   qDebug("adjusting header %d", total);
   return true;
 }
 
 int WavFile::parseWavHeader(int fd) {
   qDebug("Parsing wav header");
   char string[4];
   int found;
   short fmt;
   unsigned short ch, bitrate;
   unsigned long samplerrate, longdata;
 
   if (read(fd, string, 4) < 4) {
     qDebug(" Could not read from sound file.\n");
     return -1;
   }
   if (strncmp(string, "RIFF", 4)) {
     qDebug(" not a valid WAV file.\n");
     return -1;
   }
   lseek(fd, 4, SEEK_CUR);
   if (read(fd, string, 4) < 4) {
     qDebug("Could not read from sound file.\n");
     return -1;
   }
   if (strncmp(string, "WAVE", 4)) {
     qDebug("not a valid WAV file.\n");
     return -1;
   }
   found = 0;
 
   while (!found) {
     if (read(fd, string, 4) < 4) {
       qDebug("Could not read from sound file.\n");
       return -1;
     }
     if (strncmp(string, "fmt ", 4)) {
       if (read(fd, &longdata, 4) < 4) {
         qDebug("Could not read from sound file.\n");
         return -1;
       }
       lseek(fd, longdata, SEEK_CUR);
     } else {
       lseek(fd, 4, SEEK_CUR);
       if (read(fd, &fmt, 2) < 2) {
         qDebug("Could not read format chunk.\n");
         return -1;
       }
       if (fmt != WAVE_FORMAT_PCM && fmt != WAVE_FORMAT_DVI_ADPCM) {
         qDebug("Wave file contains unknown format."
                " Unable to continue.\n");
         return -1;
       }
       wavFormat = fmt;
       //      compressionFormat=fmt;
       qDebug("compressionFormat is %d", fmt);
       if (read(fd, &ch, 2) < 2) {
         qDebug("Could not read format chunk.\n");
         return -1;
       } else {
         wavChannels = ch;
         qDebug("File has %d channels", ch);
       }
       if (read(fd, &samplerrate, 4) < 4) {
         qDebug("Could not read from format chunk.\n");
         return -1;
       } else {
         wavSampleRate = samplerrate;
         //                sampleRate = samplerrate;
         qDebug("File has samplerate of %d",(int) samplerrate);
       }
       lseek(fd, 6, SEEK_CUR);
       if (read(fd, &bitrate, 2) < 2) {
         qDebug("Could not read format chunk.\n");
         return -1;
       }  else {
         wavResolution=bitrate;
         //                 resolution =  bitrate;
         qDebug("File has bitrate of %d", bitrate);
       }
       found++;
     }
   }
   found = 0;
   while (!found) {
     if (read(fd, string, 4) < 4) {
       qDebug("Could not read from sound file.\n");
       return -1;
     }
 
     if (strncmp(string, "data", 4)) {
       if (read(fd, &longdata, 4)<4) {
         qDebug("Could not read from sound file.\n");
         return -1;
       }
 
       lseek(fd, longdata, SEEK_CUR);
     } else {
       if (read(fd, &longdata, 4) < 4) {
         qDebug("Could not read from sound file.\n");
         return -1;
       } else {
         wavNumberSamples =  longdata;
          qDebug("file has length of %d \nlasting %d seconds", (int)longdata,
         (int)(( longdata / wavSampleRate) / wavChannels) / ( wavChannels*( wavResolution/8)) );
 //        wavSeconds = (( longdata / wavSampleRate) / wavChannels) / ( wavChannels*( wavResolution/8));
         
   return longdata;
       }
     }
   }
 
   lseek(fd, 0, SEEK_SET);
 
   return 0;
 }
 
 QString WavFile::trackName() {
     return track.name();
 }
 
 int WavFile::wavHandle(){
   return track.handle();
 }
 
 int WavFile::getFormat() {
 return wavFormat;
 }
 
 int WavFile::getResolution() {
 return wavResolution;
 }
 
 int WavFile::getSampleRate() {
  return wavSampleRate;
 }
 
 int WavFile::getNumberSamples() {
  return wavNumberSamples;
 }
 
 bool WavFile::isTempFile() {
 return useTmpFile;
 }
 
 int WavFile::getChannels() {
 
    return wavChannels;
 }
diff --git a/noncore/multimedia/opierec/waveform.cpp b/noncore/multimedia/opierec/waveform.cpp
index 05be373..9cc40b4 100644
--- a/noncore/multimedia/opierec/waveform.cpp
+++ b/noncore/multimedia/opierec/waveform.cpp
@@ -1,160 +1,159 @@
 /**********************************************************************
  ** 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 "waveform.h"
 
-#include <qlabel.h>
 #include <qpainter.h>
 
 
 Waveform::Waveform( QWidget *parent, const char *name, WFlags fl )
    : QWidget( parent, name, fl )
 {
    pixmap = 0;
    windowSize = 100;
    samplesPerPixel = 8000 / (5 * windowSize);
    currentValue = 0;
    numSamples = 0;
    windowPosn = 0;
    window = 0;
 }
 
 
 void Waveform::changeSettings( int frequency, int channels )
 {
    makePixmap();
 //   qWarning("change waveform %d, %d", frequency, channels);
    samplesPerPixel = frequency * channels / (5 * windowSize);
    qWarning("Waveform::changeSettings %d", samplesPerPixel);
    if ( !samplesPerPixel )
       samplesPerPixel = 1;
    currentValue = 0;
    numSamples = 0;
    windowPosn = 0;
    draw();
 }
 
 
 Waveform::~Waveform()
 {
    if ( window )
       delete[] window;
    if ( pixmap )
       delete pixmap;
 }
 
 
 void Waveform::reset()
 {
    makePixmap();
    currentValue = 0;
    numSamples = 0;
    windowPosn = 0;
    draw();
 }
 
 
 void Waveform::newSamples( const short *buf, int len )
 {
    // Cache the object values in local variables.
    int samplesPerPixel = this->samplesPerPixel;
    int currentValue = this->currentValue;
    int numSamples = this->numSamples;
    short *window = this->window;
    int windowPosn = this->windowPosn;
    int windowSize = this->windowSize;
 
    // Average the incoming samples to scale them to the window.
    while ( len > 0 ) {
       currentValue += *buf++;
       --len;
       if ( ++numSamples >= samplesPerPixel ) {
          window[windowPosn++] = (short)(currentValue / numSamples);
          if ( windowPosn >= windowSize ) {
             this->windowPosn = windowPosn;
             draw();
             windowPosn = 0;
          }
          numSamples = 0;
          currentValue = 0;
       }
    }
 
    // Copy the final state back to the object.
 //qWarning("%d, %d, %d", currentValue, numSamples, windowPosn);
  this->currentValue = currentValue;
    this->numSamples = numSamples;
    this->windowPosn = windowPosn;
 }
 
 
 void Waveform::makePixmap()
 {
    if ( !pixmap ) {
       pixmap = new QPixmap( size() );
       windowSize = pixmap->width();
       window = new short [windowSize];
    }
 }
 
 
 void Waveform::draw()
 {
    pixmap->fill( Qt::black );
    QPainter painter;
    painter.begin( pixmap );
    painter.setPen( Qt::green );
 
    int middle = pixmap->height() / 2;
    int mag;
    short *window = this->window;
    int posn;
    int size = windowPosn;
    for( posn = 0; posn < size; ++posn )
    {
       mag = (window[posn] * middle / 32768);
       painter.drawLine(posn, middle - mag, posn, middle + mag);
    }
    if ( windowPosn < windowSize )
    {
       painter.drawLine(windowPosn, middle, windowSize, middle);
    }
 
    painter.end();
 
    paintEvent( 0 );
 }
 
 
 void Waveform::paintEvent( QPaintEvent * )
 {
    QPainter painter;
    painter.begin( this );
 
    if ( pixmap ) {
       painter.drawPixmap( 0, 0, *pixmap );
    } else {
       painter.setPen( Qt::green );
       QSize sz = size();
       painter.drawLine(0, sz.height() / 2, sz.width(), sz.height() / 2);
    }
 
    painter.end();
 }
 
diff --git a/noncore/multimedia/powerchord/fretboard.cpp b/noncore/multimedia/powerchord/fretboard.cpp
index 0687d00..bf78e4c 100644
--- a/noncore/multimedia/powerchord/fretboard.cpp
+++ b/noncore/multimedia/powerchord/fretboard.cpp
@@ -1,234 +1,233 @@
 //
 // FretBoard class to display interface for chord finder application
 //
 
 // Copyright (c) 2001 Camilo Mesias
 // camilo@mesias.co.uk
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License
 // as published by the Free Software Foundation; either version 2
 // of the License, or (at your option) any later version.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 //#include <FL/Fl.H>
 //#include <FL/Fl_Widget.H>
 //#include <FL/fl_draw.H>
 #include <stdio.h>
-#include <qpixmap.h>
 #include <qpe/resource.h>
 #include "fretboard.h"
 #include <qpainter.h>
 
 void FretBoard::refresh(){
   ce.calculate();
 
   emit nameChanged(QString(ce.label()));
 
   for (int i=0;i<6;i++){
     Finger(i, ce.finger(i));
     // yuk
     switch (i) {
     case 0:
       emit s1nameChanged(QString(ce.name(i)));
       break;
     case 1:
       emit s2nameChanged(QString(ce.name(i)));
       break;
     case 2:
       emit s3nameChanged(QString(ce.name(i)));
       break;
     case 3:
       emit s4nameChanged(QString(ce.name(i)));
       break;
     case 4:
       emit s5nameChanged(QString(ce.name(i)));
       break;
     case 5:
       emit s6nameChanged(QString(ce.name(i)));
       break;
     }
   }
 
   update();
 }
 
 FretBoard::FretBoard(QWidget *parent, const char *name )
   : QWidget( parent, name ), ce()
 {
   
   ce.base(9);
   ce.chord(0);
   ce.fret(0);
   ce.span(1);
   ce.vary(7);
   ce.tune(0);
   refresh();
 
   //  setPalette( QPalette( QColor( 250, 250, 200) ) );
 
   stringtop_pix = Resource::loadPixmap( "powerchord/stringtop_s");
   string_pix = Resource::loadPixmap( "powerchord/string_s");
   finger_pix = Resource::loadPixmap( "powerchord/justfing_s");
   mute_pix = Resource::loadPixmap( "powerchord/muted_s");
 
   //  box(FL_NO_BOX);
 
   //  finger[0] = OPEN;
   //  finger[1] = OPEN;
   //  finger[2] = OPEN;
   //  finger[3] = OPEN;
   //  finger[4] = OPEN;
   //  finger[5] = OPEN;
 
   initial_fret = 0;
 
   //  label(FL_NORMAL_LABEL, "Chord");
 }
 
 //  int FretBoard::Finger(int f){
 //    if (f < 0 || f > 5){
 //      fprintf(stderr, "Error - finger value was %d\n", f);
 //      return 0;
 //    }
 //    return finger[f];
 //  }
 
 void FretBoard::Finger(int f, int position){
   if (f < 0 || f > 5){
     fprintf(stderr, "Error - finger2 value was %d\n", f);
     return;
   }
   
   finger[f] = position;
 }
 
 //  void FretBoard::draw(void) {
 //    draw_box();
 //    draw_label();
 //  }
 
 //  void FretBoard::draw_label(void) {
 //    align(FL_ALIGN_CENTER | FL_ALIGN_TOP | FL_ALIGN_WRAP);
 
 //    this->Fl_Widget::draw_label();
 //  }
 
 
 //void FretBoard::draw_box(void) {
   
 void FretBoard::paintEvent(QPaintEvent *){
 
   //  fl_color(FL_WHITE);
 
   //  Fl_Widget::draw_box();
 
   //  fl_color(FL_BLACK);
 
   QPainter p( this );
 
   p.setBrush(black);
   p.translate(0, 0);
 
   // draw each string
   for (int f=0; f<=5; f++){
     // draw a string starting from the highest visible fret
     for (int pp=0; pp<=6; pp++){
       int this_fret = initial_fret + pp;
       int cx = /* x() + */ 28*f;
       int cy = /* y() + */ pp*30;
 
               //fl_color(FL_WHITE);
         //  fl_rectf(cx, cy, 24, 24);
       //      p.setBrush(white);
       //      p.setPen(NoPen);
 
       //      p.drawRect( QRect(cx, cy, 24, 24) );
 //          fl_color(FL_BLACK);
       //      p.setBrush(black);
 
       //      p.setPen(black);
 
       // draw the string unless at top
       if (this_fret!=0){
                 //fl_line(cx+12, cy, cx+12, cy+23);
                 //p.drawLine(cx+12, cy, cx+12, cy+23);
       }
 
       // draw mutes if at top
       if (pp == 0 &&
           finger[f] == MUTED){
         p.drawPixmap(cx,cy,mute_pix);
                 //fl_line(cx+4, cy+19, cx+19, cy+4);
                 //p.drawLine(cx+4, cy+19, cx+19, cy+4);
                 //fl_line(cx+5, cy+19, cx+20, cy+4);
                 //p.drawLine(cx+5, cy+19, cx+20, cy+4);
                 //fl_line(cx+4, cy+4, cx+19, cy+19);
                 //p.drawLine(cx+4, cy+4, cx+19, cy+19);
                 //fl_line(cx+5, cy+4, cx+20, cy+19);
                 //p.drawLine(cx+5, cy+4, cx+20, cy+19);
       }
 
       if (this_fret==0){
         // above, blank
       }else if(this_fret==1){
         // top
         p.drawPixmap(cx,cy,stringtop_pix);
       }else{
         // normal
         p.drawPixmap(cx,cy,string_pix);
       }
 
       // frets at bottom
       // thick line if at top
       //      int x0 = (f==0)?(cx+12):cx;
       //      int x1 = (f==5)?(cx+12):(cx+23);
       //      for (int offset=23; offset>((this_fret==0)?20:22); offset--){
                 //fl_line(x0, cy+offset, x1, cy+offset);
                 //p.drawLine(x0, cy+offset, x1, cy+offset);
       //      }
 
       // finger if at that position
       if ((initial_fret==0 && pp == finger[f]) ||
           (initial_fret!=0 && pp == finger[f]-8)){
         p.drawPixmap(cx,cy,finger_pix);
 
         //  fl_color(FL_WHITE);
         //  p.setBrush(white);
         //  p.setPen(NoPen);
         
         //  fl_rectf(cx+4, cy+4, 16, 16);
                 //p.drawRect( QRect(cx+4, cy+4, 16, 16));
 //          fl_color(FL_BLACK);
         //p.setPen(black);
         //  fl_line(cx+4, cy+11, cx+7, cy+16);
         //p.drawLine(cx+4, cy+11, cx+7, cy+16);
         //  fl_line(cx+7, cy+16, cx+12, cy+19);
         //p.drawLine(cx+7, cy+16, cx+12, cy+19);
         //  fl_line(cx+12, cy+19, cx+16, cy+16);
         //p.drawLine(cx+12, cy+19, cx+16, cy+16);
         //  fl_line(cx+16, cy+16, cx+19, cy+12);
         //p.drawLine(cx+16, cy+16, cx+19, cy+12);
         //  fl_line(cx+19, cy+12, cx+16, cy+7);
         //p.drawLine(cx+19, cy+12, cx+16, cy+7);
         //  fl_line(cx+16, cy+7, cx+12, cy+4);
         //p.drawLine(cx+16, cy+7, cx+12, cy+4);
         //  fl_line(cx+11, cy+4, cx+7, cy+7);
         //p.drawLine(cx+11, cy+4, cx+7, cy+7);
         //  fl_line(cx+7, cy+7, cx+4, cy+11);
         //p.drawLine(cx+7, cy+7, cx+4, cy+11);
       }
     }
   }
   p.end();
 }
 
 
diff --git a/noncore/multimedia/powerchord/gs.cpp b/noncore/multimedia/powerchord/gs.cpp
index fdcfb74..69d9d75 100644
--- a/noncore/multimedia/powerchord/gs.cpp
+++ b/noncore/multimedia/powerchord/gs.cpp
@@ -1,465 +1,463 @@
 
 //#include <FL/Fl.H>
 //#include <FL/Fl_Widget.H>
 //#include <FL/fl_draw.H>
 #include <stdio.h>
 //#include <qpixmap.h>
 #include "gs.h"
 
 #include <sys/ioctl.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/soundcard.h>
 
 #include <errno.h>
 #include <string.h>
 
 #include <stdlib.h>
 
 //#include <qpainter.h>
-#include <qmessagebox.h>
-#include <qstring.h>
 
 
 gs::gs()
 {
   
   finger[0] = OPEN;
   finger[1] = OPEN;
   finger[2] = OPEN;
   finger[3] = OPEN;
   finger[4] = OPEN;
   finger[5] = OPEN;
 
   tuning[0] = 0;
   tuning[1] = 0;
   tuning[2] = 0;
   tuning[3] = 0;
   tuning[4] = 0;
   tuning[5] = 0;
 
   initial_fret = 0;
 
   audio_fd = -1;
   
   pb_rate0 = 0;
   pb_rate1 = 0;
   pb_rate2 = 0;
   pb_rate3 = 0;
   pb_rate4 = 0;
   pb_rate5 = 0;
   pb_rate6 = 0;
 
   pb_oct0 = 0;
   pb_oct1 = 0;
   pb_oct2 = 0;
   pb_oct3 = 0;
   pb_oct4 = 0;
   pb_oct5 = 0;
   pb_oct6 = 0;
 
   // initialise reverb buffer
   reverb = (signed short *)malloc(1024 * sizeof(signed short));
 
   for (reverb_ptr=0;reverb_ptr<1024;reverb_ptr++){
     reverb[reverb_ptr] = 0;
   }
   reverb_ptr = 0;
   reverb_max = 1024;
 
   // load sampled 'E' string
   int samplen = 25000;
 
   signed short *dsp_buf = (signed short *)malloc(samplen * sizeof(signed short));
   signed short *dsp_buf_ptr = dsp_buf;
 
   int raw_fd;
 
   QString path = getenv( "OPIEDIR" );
   path.append( "/share/powerchord/acguitar.raw" );
 
   raw_fd = open( (const char*) path, O_RDONLY);
 
   if (raw_fd < 0){
       fprintf(stderr, "Failed to open raw file (%s)\n", strerror(errno));
       exit(-1);
   }
 
   int totread = 0;
   int i;
 
   while (totread < samplen*2){
       int want = samplen*2 - totread;
 
       int numread = read(raw_fd, dsp_buf_ptr, want);
       fprintf(stderr, "read %d bytes\n", numread);
       totread += numread;
       dsp_buf_ptr += numread/2;
 
       if (numread == 0){
           fprintf(stderr, "failed to read bytes\n");
           exit(-1);
       }    
   }
 
   close(raw_fd);
 
   // scale down a bit for mixing
   for (i=0;i<samplen;i++){
     dsp_buf[i] /= 6;
   }
   
   set_tonebank(0, dsp_buf, samplen);
   set_tonebank(1, dsp_buf, samplen);
   set_tonebank(2, dsp_buf, samplen);
   set_tonebank(3, dsp_buf, samplen);
   set_tonebank(4, dsp_buf, samplen);
   set_tonebank(5, dsp_buf, samplen);
   set_tonebank(6, dsp_buf, samplen);
   
 }
 
 void gs::set_tonebank(int tb, signed short *buf, int length)
 {
     switch(tb){
     case 0:
         tonebank0 = buf;
         tonebank_length0 = length;
         break;
     case 1:
         tonebank1 = buf;
         tonebank_length1 = length;
         break;
     case 2:
         tonebank2 = buf;
         tonebank_length2 = length;
         break;
     case 3:
         tonebank3 = buf;
         tonebank_length3 = length;
         break;
     case 4:
         tonebank4 = buf;
         tonebank_length4 = length;
         break;
     case 5:
         tonebank5 = buf;
         tonebank_length5 = length;
         break;
     case 6:
         tonebank6 = buf;
         tonebank_length6 = length;
         break;
         
     }
 }
 
 
 void gs::Finger(int f, int position){
   if (f < 0 || f > 5){
     fprintf(stderr, "Error - finger2 value was %d\n", f);
     return;
   }
 
   finger[f] = position;
 }
 
 void gs::Tuning(int t[6]){
   for (int i=0;i<6;i++){
     tuning[i] = t[i];
   }
 }
 
 // length in ps (seconds x 10^-9) of the period of a note.
 // we use these as ratios in a breshenham-like algorithm to
 // scale a deep note to a higher pitch
 // They are derived from f(A) = 440Hz and multiply each successive
 // semitone by the 12th root of 2 (such that after 12 multiplications for
 // 12 semitones you have a note exactly 2x the frequency of the initial one,
 // - an octave higher in other words.)
 
 int gs::note_periods[12] = {
 90703,
 85612,
 80802,
 76272,
 71991,
 67950,
 64137,
 60537,
 57139,
 53932,
 50905,
 48048
 };
 
 int gs::octave_step[6] = {
   1,
   2,
   4,
   8,
   16,
   32
 };
 
 int gs::Play(){
     int format;
     int channels;
     int speed;
 
     frames = 0;
 
     if (audio_fd == -1){
         if ( (audio_fd = open("/dev/dsp", O_WRONLY, 0) ) == -1){    
           audio_fd = -1;
           return 1;
         }
         
         format = AFMT_S16_NE;
         
         if (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &format) == -1){
             fprintf(stderr, "Error SNDCTL DSP SETFMT, %s\n", strerror(errno));
             exit(0);
         }
 
         channels = 1;
 
         if (ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &channels) == -1){
             fprintf(stderr, "Error SNDCTL DSP CHANNELS, %s\n", strerror(errno));
             exit(0);
         }
         
         speed = 11025;
         
         if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &speed) == -1){
             fprintf(stderr, "Error SNDCTL DSP SPEED, %s\n", strerror(errno));
             exit(0);
         }
 
         // buffering q's
                 //audio_buf_info info;
                 //if (ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info) == -1){
                 //    fprintf(stderr, "Error SNDCTL DSP GETOSPACE, %s\n", strerror(errno));
                 //    exit(0);
                 //}
                 //fprintf(stderr, "fragments %d\nfragstotal %d\nfragsize %d\nbytes %d\n", info.fragments, info.fragstotal, info.fragsize, info.bytes);
         
         
         
 // audio math.
 // A4 = 440Hz
 // +1 octave = 2x freq
 // -1 octave = /2 freq.
 // +1 semitone = *= 12 root 2;
 // ie. * 1.059463094
 
 // tones, approx Hz, samples at 11025
 // A4    440  25
 // A#4   466  24
 // B4    494  22
 // C4    523  21
 // C#4   554  20
 // D4    587  19
 // D#4   622  18
 // E4    659  17
 // F4    698  16
 // F#4   740  15
 // G4    784  14
 // G#4   831  13
 
         
     }
     else{
         fprintf(stderr, "Already playing\n");
     }
     
     return 0;
 }
 
 void gs::note_start(int chan, int note, int octave)
 {
     switch (chan){
         
     case 0:
         pb_rate0 = note_periods[note];
         pb_oct0 = octave_step[octave];
         pb_ratio0 = 0;
         pb_rsc0 = 0;
         break;
     case 1:
         pb_rate1 = note_periods[note];
         pb_oct1 = octave_step[octave];
         pb_ratio1 = 0;
         pb_rsc1 = 0;
         break;
     case 2:
         pb_rate2 = note_periods[note];
         pb_oct2 = octave_step[octave];
         pb_ratio2 = 0;
         pb_rsc2 = 0;
         break;
     case 3:
         pb_rate3 = note_periods[note];
         pb_oct3 = octave_step[octave];
         pb_ratio3 = 0;
         pb_rsc3 = 0;
         break;
     case 4:
         pb_rate4 = note_periods[note];
         pb_oct4 = octave_step[octave];
         pb_ratio4 = 0;
         pb_rsc4 = 0;
         break;
     case 5:
         pb_rate5 = note_periods[note];
         pb_oct5 = octave_step[octave];
         pb_ratio5 = 0;
         pb_rsc5 = 0;
         break;
     case 6:
         pb_rate6 = note_periods[note];
         pb_oct6 = octave_step[octave];
         pb_ratio6 = 0;
         pb_rsc6 = 0;
         break;
     default:
         fprintf(stderr, "Bad channel\n");
         exit(-1);
     }
     
   
 }
 
 void gs::write_buffer(){
   int num_read;
   num_read = write(audio_fd, (void *)audio_buf, BUFSIZE*2);
   //  fprintf(stderr, "Wrote %d bytes\n", num_read);
 }
 
 void gs::fill_buffer()
 {
   frames ++;
 
   int i;
 
   for (i=0;i<BUFSIZE;i++){
       
       audio_buf[i] = 0;
       
       if (pb_rate0){
           audio_buf[i] += tonebank0[pb_rsc0];
           pb_rsc0 += pb_oct0;
           pb_ratio0 += 90703;
           pb_ratio0 -= pb_rate0;
           if (pb_ratio0 >= pb_rate0){
               pb_rsc0 += pb_oct0;
               pb_ratio0 -= pb_rate0;
               
           }
           if (pb_rsc0 >= tonebank_length0) pb_rate0 = 0;
       }
 
       if (pb_rate1){
           audio_buf[i] += tonebank1[pb_rsc1];
           pb_rsc1 += pb_oct1;
           pb_ratio1 += 90703;
           pb_ratio1 -= pb_rate1;
           if (pb_ratio1 >= pb_rate1){
               pb_rsc1 += pb_oct1;
               pb_ratio1 -= pb_rate1;
               
           }
           if (pb_rsc1 >= tonebank_length1) pb_rate1 = 0;
       }
 
       if (pb_rate2){
           audio_buf[i] += tonebank2[pb_rsc2];
           pb_rsc2 += pb_oct2;
           pb_ratio2 += 90703;
           pb_ratio2 -= pb_rate2;
           if (pb_ratio2 >= pb_rate2){
               pb_rsc2 += pb_oct2;
               pb_ratio2 -= pb_rate2;
               
           }
           if (pb_rsc2 >= tonebank_length2) pb_rate2 = 0;
       }
 
       if (pb_rate3){
           audio_buf[i] += tonebank3[pb_rsc3];
           pb_rsc3 += pb_oct3;
           pb_ratio3 += 90703;
           pb_ratio3 -= pb_rate3;
           if (pb_ratio3 >= pb_rate3){
               pb_rsc3 += pb_oct3;
               pb_ratio3 -= pb_rate3;
               
           }
           if (pb_rsc3 >= tonebank_length3) pb_rate3 = 0;
       }
 
       if (pb_rate4){
           audio_buf[i] += tonebank4[pb_rsc4];
           pb_rsc4 += pb_oct4;
           pb_ratio4 += 90703;
           pb_ratio4 -= pb_rate4;
           if (pb_ratio4 >= pb_rate4){
               pb_rsc4 += pb_oct4;
               pb_ratio4 -= pb_rate4;
               
           }
           if (pb_rsc4 >= tonebank_length4) pb_rate4 = 0;
       }
 
       if (pb_rate5){
           audio_buf[i] += tonebank5[pb_rsc5];
           pb_rsc5 += pb_oct5;
           pb_ratio5 += 90703;
           pb_ratio5 -= pb_rate5;
           if (pb_ratio5 >= pb_rate5){
               pb_rsc5 += pb_oct5;
               pb_ratio5 -= pb_rate5;
               
           }
           if (pb_rsc5 >= tonebank_length5) pb_rate5 = 0;
       }
 
       if (pb_rate6){
           audio_buf[i] += tonebank6[pb_rsc6];
           pb_rsc6 += pb_oct6;
           pb_ratio6 += 90703;
           pb_ratio6 -= pb_rate6;
           if (pb_ratio6 >= pb_rate6){
               pb_rsc6 += pb_oct6;
               pb_ratio6 -= pb_rate6;
               
           }
           if (pb_rsc6 >= tonebank_length6) pb_rate6 = 0;
       }
 
       // do reverb
       signed short rtmp = reverb[reverb_ptr];
       reverb[reverb_ptr] /= 2;
       reverb[reverb_ptr] += audio_buf[i]/4;
       audio_buf[i] += rtmp;
       reverb_ptr++;
       if (reverb_ptr >= reverb_max) reverb_ptr = 0;
   }
 }
 
 
 void gs::Stop(){
     if (audio_fd == -1){
         fprintf(stderr, "Already stopped\n");
     }
     else{
         //ioctl(audio_fd, SNDCTL_DSP_RESET, 0);
         
         close(audio_fd);
         audio_fd = -1;
     }
     
 }
 
 gs::~gs()
 {}
diff --git a/noncore/multimedia/powerchord/powerchord.cpp b/noncore/multimedia/powerchord/powerchord.cpp
index 79a26ea..31d517b 100644
--- a/noncore/multimedia/powerchord/powerchord.cpp
+++ b/noncore/multimedia/powerchord/powerchord.cpp
@@ -1,28 +1,27 @@
 #include "powerchord.h"
-#include <qpushbutton.h>
 
 /* 
  *  Constructs a Example which is a child of 'parent', with the 
  *  name 'name' and widget flags set to 'f' 
  */
 Powerchord::Powerchord( QWidget* parent,  const char* name, WFlags fl )
     : PowerchordBase( parent, name, fl )
 {
 //    connect(quit, SIGNAL(clicked), this, SLOT(goodBye()));
 }
 
 /*  
  *  Destroys the object and frees any allocated resources
  */
 Powerchord::~Powerchord()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 /*
  *  A simple slot... not very interesting.
  */
 void Powerchord::goodBye()
 {
     close();
 }
diff --git a/noncore/multimedia/powerchord/powerchordbase.cpp b/noncore/multimedia/powerchord/powerchordbase.cpp
index 7978426..4fb5dda 100644
--- a/noncore/multimedia/powerchord/powerchordbase.cpp
+++ b/noncore/multimedia/powerchord/powerchordbase.cpp
@@ -1,592 +1,585 @@
 /****************************************************************************
 ** Form implementation generated from reading ui file 'powerchordbase.ui'
 **
 ** Created: Sun Jan 13 23:05:11 2002
 **      by:  The User Interface Compiler (uic)
 **
 ** WARNING! All changes made in this file will be lost!
 ****************************************************************************/
 #include "powerchordbase.h"
 
 #include "fretboard.h"
 #include "vumeter.h"
-#include "gs.h"
 #include <qcombobox.h>
-#include <qframe.h>
 #include <qlabel.h>
 #include <qlistbox.h>
 #include <qpushbutton.h>
 #include <qspinbox.h>
 #include <qtabwidget.h>
 #include <qlayout.h>
-#include <qvariant.h>
 #include <qtooltip.h>
-#include <qwhatsthis.h>
-#include <qimage.h>
-#include <qpixmap.h>
-#include <qbitmap.h>
 #include <qpe/resource.h>
 
 
 /*
  *  Constructs a PowerchordBase which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  */
 PowerchordBase::PowerchordBase( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
   simulation_timer = 0;
   audio_timer = 0;
 
   //    setPalette( QPalette( QColor( 232, 227, 215) ) );
 
   //  QPixmap image0(QString("/opt/Qtopia/pics/powerchord/image0"));
   QPixmap image1 = Resource::loadPixmap( "powerchord/image1");
   QPixmap image2 = Resource::loadPixmap( "powerchord/image2");
   QPixmap image3 = Resource::loadPixmap( "powerchord/image3");
   QPixmap image4 = Resource::loadPixmap( "powerchord/image4");
   QPixmap image5 = Resource::loadPixmap( "powerchord/image5");
   image6 = Resource::loadPixmap( "powerchord/image6");
   image_open = Resource::loadPixmap( "powerchord/image_open");
 
   //  image0.setMask(image0.createHeuristicMask());
    image1.setMask(image1.createHeuristicMask());
     //    image2.setMask(image2.createHeuristicMask());
     //    image3.setMask(image3.createHeuristicMask());
     //    image4.setMask(image4.createHeuristicMask());
     //    image5.setMask(image5.createHeuristicMask());
     //    image6->setMask(image6->createHeuristicMask());
     //    image_open->setMask(image_open->createHeuristicMask());
 
     if ( !name )
         setName( "PowerchordBase" );
     resize( 240, 284 );
     setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)5, (QSizePolicy::SizeType)5, sizePolicy().hasHeightForWidth() ) );
     setMinimumSize( QSize( 240, 284 ) );
     setMaximumSize( QSize( 240, 284 ) );
     setCaption( tr( "Powerchord" ) );
 
     tabs = new QTabWidget( this, "tabs" );
     tabs->setEnabled( TRUE );
     tabs->setGeometry( QRect( 0, 0, 240, 286 ) ); 
     tabs->setTabPosition( QTabWidget::Bottom );
 
     tab = new QWidget( tabs, "tab" );
 
     chordkey = new QComboBox( FALSE, tab, "chordkey" );
     chordkey->insertItem( tr( "maj" ) );
     chordkey->insertItem( tr( "min" ) );
     chordkey->insertItem( tr( "7th" ) );
     chordkey->insertItem( tr( "m7" ) );
     chordkey->insertItem( tr( "maj7" ) );
     chordkey->insertItem( tr( "6th" ) );
     chordkey->insertItem( tr( "m6th" ) );
     chordkey->insertItem( tr( "aug" ) );
     chordkey->insertItem( tr( "dim" ) );
     chordkey->insertItem( tr( "sus4" ) );
     chordkey->insertItem( tr( "7sus4" ) );
     chordkey->insertItem( tr( "9th" ) );
     chordkey->insertItem( tr( "add9" ) );
     chordkey->insertItem( tr( "m9th" ) );
     chordkey->insertItem( tr( "maj9" ) );
     chordkey->insertItem( tr( "sus2" ) );
     chordkey->insertItem( tr( "7sus2" ) );
     chordkey->insertItem( tr( "11th" ) );
     chordkey->insertItem( tr( "m11th" ) );
     chordkey->insertItem( tr( "13th" ) );
     chordkey->insertItem( tr( "m13th" ) );
     chordkey->insertItem( tr( "maj13" ) );
     chordkey->insertItem( tr( "6/9" ) );
     chordkey->insertItem( tr( "flat5" ) );
     chordkey->insertItem( tr( "7#9" ) );
     chordkey->insertItem( tr( QString::fromUtf8( "ø7" ) ) );
     chordkey->insertItem( tr( "5" ) );
     chordkey->setGeometry( QRect( 40, 0, 51, 21 ) ); 
 
     chordfret = new QComboBox( FALSE, tab, "chordfret" );
     chordfret->insertItem( tr( "open" ) );
     chordfret->insertItem( tr( "1st" ) );
     chordfret->insertItem( tr( "2nd" ) );
     chordfret->insertItem( tr( "3rd" ) );
     chordfret->insertItem( tr( "4th" ) );
     chordfret->insertItem( tr( "5th" ) );
     chordfret->insertItem( tr( "6th" ) );
     chordfret->insertItem( tr( "7th" ) );
     chordfret->insertItem( tr( "8th" ) );
     chordfret->insertItem( tr( "9th" ) );
     chordfret->insertItem( tr( "10th" ) );
     chordfret->insertItem( tr( "11th" ) );
     chordfret->insertItem( tr( "12th" ) );
     chordfret->insertItem( tr( "13th" ) );
     chordfret->insertItem( tr( "14th" ) );
     chordfret->insertItem( tr( "15th" ) );
     chordfret->insertItem( tr( "16th" ) );
     chordfret->setGeometry( QRect( 90, 0, 55, 21 ) ); //cxm less 5 width
 
     chordnote = new QComboBox( FALSE, tab, "chordnote" );
     chordnote->insertItem( tr( "C" ) );
     chordnote->insertItem( tr( "C#" ) );
     chordnote->insertItem( tr( "D" ) );
     chordnote->insertItem( tr( "Eb" ) );
     chordnote->insertItem( tr( "E" ) );
     chordnote->insertItem( tr( "F" ) );
     chordnote->insertItem( tr( "F#" ) );
     chordnote->insertItem( tr( "G" ) );
     chordnote->insertItem( tr( "G#" ) );
     chordnote->insertItem( tr( "A" ) );
     chordnote->insertItem( tr( "Bb" ) );
     chordnote->insertItem( tr( "B" ) );
     chordnote->setGeometry( QRect( 0, 0, 40, 21 ) ); 
     chordnote->setCurrentItem( 9 );
 
     QWidget* privateLayoutWidget = new QWidget( tab, "Layout1" );
     privateLayoutWidget->setGeometry( QRect( 5, 232, 160, 20 ) ); 
     Layout1 = new QHBoxLayout( privateLayoutWidget ); 
     Layout1->setSpacing( 6 );
     Layout1->setMargin( 0 );
 
     s1_1 = new QLabel( privateLayoutWidget, "s1_1" );
     s1_1->setText( tr( "E" ) );
     s1_1->setAlignment( int( QLabel::AlignCenter ) );
     Layout1->addWidget( s1_1 );
 
     s1_2 = new QLabel( privateLayoutWidget, "s1_2" );
     s1_2->setText( tr( "A" ) );
     s1_2->setAlignment( int( QLabel::AlignCenter ) );
     Layout1->addWidget( s1_2 );
 
     s1_3 = new QLabel( privateLayoutWidget, "s1_3" );
     s1_3->setText( tr( "E" ) );
     s1_3->setAlignment( int( QLabel::AlignCenter ) );
     Layout1->addWidget( s1_3 );
 
     s1_4 = new QLabel( privateLayoutWidget, "s1_4" );
     s1_4->setText( tr( "A" ) );
     s1_4->setAlignment( int( QLabel::AlignCenter ) );
     Layout1->addWidget( s1_4 );
 
     s1_5 = new QLabel( privateLayoutWidget, "s1_5" );
     s1_5->setText( tr( "C#" ) );
     s1_5->setAlignment( int( QLabel::AlignCenter ) );
     Layout1->addWidget( s1_5 );
 
     s1_6 = new QLabel( privateLayoutWidget, "s1_6" );
     s1_6->setText( tr( "E" ) );
     s1_6->setAlignment( int( QLabel::AlignCenter ) );
     Layout1->addWidget( s1_6 );
 
     //    sound_label = new QLabel( tab, "sound_label" );
     //    sound_label->setGeometry( QRect( 185, 160, 32, 17 ) ); 
     //    sound_label->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)0, (QSizePolicy::SizeType)0, sound_label->sizePolicy().hasHeightForWidth() ) );
     //    sound_label->setPixmap( image0 );
     //    sound_label->pixmap()->setMask(*image0.mask());
     //    sound_label->setScaledContents( TRUE );
     //  sound_label->setBackgroundMode( QWidget::PaletteButton );
     //    sound_label->setBackgroundColor(this->backgroundColor());
     //    sound_label->setPalette( QPalette( QColor( 232, 227, 215) ) );
 
 
     Frame6 = new QFrame( tab, "Frame6" );
     Frame6->setGeometry( QRect( 170, 145, 66, 10 ) ); 
     Frame6->setFrameShape( QFrame::HLine );
     Frame6->setFrameShadow( QFrame::Raised );
 
     chordshow_label = new QLabel( tab, "chordshow_label" );
     chordshow_label->setGeometry( QRect( 185, 60, 32, 17 ) ); 
     //    chordshow_label->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)0, (QSizePolicy::SizeType)0, chordshow_label->sizePolicy().hasHeightForWidth() ) );
     chordshow_label->setFrameShape( QLabel::NoFrame );
     chordshow_label->setPixmap( image1 );
     chordshow_label->setScaledContents( TRUE );
     //    chordshow_label->setBackgroundMode( QWidget::PaletteButton );
 
     transport_rec = new QPushButton( tab, "transport_rec" );
     transport_rec->setGeometry( QRect( 170, 80, 30, 30 ) ); 
     transport_rec->setText( tr( "" ) );
     transport_rec->setPixmap( image2 );
 
     play_sound = new QPushButton( tab, "play_sound" );
     play_sound->setGeometry( QRect( 170, 180, 60, 55 ) ); 
     play_sound->setText( tr( "" ) );
     play_sound->setPixmap( image3 );
 
     Frame6_2 = new QFrame( tab, "Frame6_2" );
     Frame6_2->setGeometry( QRect( 170, 45, 66, 10 ) ); 
     Frame6_2->setFrameShape( QFrame::HLine );
     Frame6_2->setFrameShadow( QFrame::Raised );
 
     transport_play = new QPushButton( tab, "transport_play" );
     transport_play->setEnabled( FALSE );
     transport_play->setGeometry( QRect( 200, 80, 30, 30 ) ); 
     transport_play->setText( tr( "" ) );
     transport_play->setPixmap( image3 );
 
     transport_rew = new QPushButton( tab, "transport_rew" );
     transport_rew->setEnabled( FALSE );
     transport_rew->setGeometry( QRect( 170, 110, 30, 30 ) ); 
     transport_rew->setText( tr( "" ) );
     transport_rew->setPixmap( image4 );
 
     transport_fwd = new QPushButton( tab, "transport_fwd" );
     transport_fwd->setEnabled( FALSE );
     transport_fwd->setGeometry( QRect( 200, 110, 30, 30 ) ); 
     transport_fwd->setText( tr( "" ) );
     transport_fwd->setPixmap( image5 );
 
     chordname = new QLabel( tab, "chordname" );
     chordname->setGeometry( QRect( 146, 0, 90, 20 ) ); //cxm moved l 5
     chordname->setText( tr( "A" ) );
     chordname->setAlignment( int( QLabel::AlignCenter ) );
     QToolTip::add(  chordname, tr( "" ) );
 
     synth = new gs();
     tuner = new gt();
     frets = new FretBoard( tab, "frets" );
     frets->setGeometry( QRect( 0, 20, 168, 210 ) ); 
     tabs->insertTab( tab, tr( "Guitar" ) );
 
     tab_2 = new QWidget( tabs, "tab_2" );
 
     optlab2 = new QLabel( tab_2, "optlab2" );
     optlab2->setGeometry( QRect( 9, 58, 120, 41 ) ); 
     optlab2->setText( tr( "Alternative tunings are possible" ) );
     optlab2->setAlignment( int( QLabel::WordBreak | QLabel::AlignVCenter | QLabel::AlignLeft ) );
 
     span = new QComboBox( FALSE, tab_2, "span" );
     span->insertItem( tr( "2" ) );
     span->insertItem( tr( "3" ) );
     span->insertItem( tr( "4" ) );
     span->insertItem( tr( "5" ) );
     span->insertItem( tr( "6" ) );
     span->setGeometry( QRect( 180, 20, 50, 21 ) ); 
     span->setCurrentItem( 1 );
 
     TextLabel1 = new QLabel( tab_2, "TextLabel1" );
     TextLabel1->setGeometry( QRect( 3, 109, 226, 140 ) ); 
     TextLabel1->setText( tr( QString::fromUtf8( "©2002 Camilo Mesias\n"
 "camilo@mesias.co.uk\n"
 "Version 0.0.7 beta" ) ) );
     TextLabel1->setAlignment( int( QLabel::AlignBottom | QLabel::AlignLeft ) );
 
     tuning = new QComboBox( FALSE, tab_2, "tuning" );
     tuning->insertItem( tr( "EADGBE" ) );
     tuning->insertItem( tr( "EBEG#BE" ) );
     tuning->insertItem( tr( "EAEAC#E" ) );
     tuning->insertItem( tr( "EADF#BE" ) );
     tuning->insertItem( tr( "EADGCF" ) );
     tuning->insertItem( tr( "DADGAD" ) );
     tuning->insertItem( tr( "DGCGCD" ) );
     tuning->insertItem( tr( "DADF#AD" ) );
     tuning->insertItem( tr( "DADGBE" ) );
     tuning->insertItem( tr( "DGDGBD" ) );
     tuning->insertItem( tr( "DADACD" ) );
     tuning->insertItem( tr( "CGCGAE" ) );
     tuning->insertItem( tr( "FADGBE" ) );
     tuning->insertItem( tr( "G minor" ) );
     tuning->setGeometry( QRect( 140, 70, 91, 21 ) ); 
 
     optlab1 = new QLabel( tab_2, "optlab1" );
     optlab1->setGeometry( QRect( 8, 8, 160, 40 ) ); 
     optlab1->setText( tr( "Span: the greatest number of frets over which you want chords to be generated" ) );
     optlab1->setAlignment( int( QLabel::WordBreak | QLabel::AlignVCenter | QLabel::AlignLeft ) );
     tabs->insertTab( tab_2, tr( "Options" ) );
 
     Tuner = new QWidget( tabs, "Tuner" );
 
     Frame4 = new QFrame( Tuner, "Frame4" );
     Frame4->setGeometry( QRect( 0, 0, 230, 126 ) ); 
     Frame4->setFrameShape( QFrame::Box );
     Frame4->setFrameShadow( QFrame::Raised );
 
     vu = new VUMeter( Frame4, "vu" );
     vu->setGeometry( QRect( 5, 5, 220, 115 ) ); 
 
     tuner_note = new QComboBox( FALSE, Tuner, "tuner_note" );
     tuner_note->insertItem( tr( "auto" ) );
     tuner_note->insertItem( tr( "E" ) );
     tuner_note->insertItem( tr( "D" ) );
     tuner_note->insertItem( tr( "G" ) );
     tuner_note->insertItem( tr( "A" ) );
     tuner_note->insertItem( tr( "B" ) );
     tuner_note->insertItem( tr( "C" ) );
     tuner_note->insertItem( tr( "F" ) );
     tuner_note->setGeometry( QRect( 5, 160, 90, 20 ) ); 
 
     Frame8 = new QFrame( Tuner, "Frame8" );
     Frame8->setGeometry( QRect( -2, 188, 231, 10 ) ); 
     Frame8->setFrameShape( QFrame::HLine );
     Frame8->setFrameShadow( QFrame::Raised );
 
     tuner_start = new QPushButton( Tuner, "tuner_start" );
     tuner_start->setGeometry( QRect( 100, 155, 91, 30 ) ); 
     tuner_start->setText( tr( "Start" ) );
 
     tuner_lab1 = new QLabel( Tuner, "tuner_lab1" );
     tuner_lab1->setGeometry( QRect( 10, 130, 100, 21 ) ); 
     tuner_lab1->setText( tr( "Tuner operation" ) );
 
     tuner_lab2 = new QLabel( Tuner, "tuner_lab2" );
     tuner_lab2->setGeometry( QRect( 10, 200, 100, 16 ) ); 
     tuner_lab2->setText( tr( "Pitch calibration" ) );
 
     tuner_calib_note = new QComboBox( FALSE, Tuner, "tuner_calib_note" );
     tuner_calib_note->insertItem( tr( "A" ) );
     tuner_calib_note->insertItem( tr( "C" ) );
     tuner_calib_note->setGeometry( QRect( 5, 225, 90, 21 ) ); 
 
     tuner_calib_freq = new QSpinBox( Tuner, "tuner_calib_freq" );
     tuner_calib_freq->setGeometry( QRect( 105, 225, 71, 21 ) ); 
     tuner_calib_freq->setSuffix( tr( "Hz" ) );
     tuner_calib_freq->setWrapping( TRUE );
     tuner_calib_freq->setMaxValue( 500 );
     tuner_calib_freq->setMinValue( 300 );
     tuner_calib_freq->setValue( 440 );
 
     tuner_lab3 = new QLabel( Tuner, "tuner_lab3" );
     tuner_lab3->setGeometry( QRect( 185, 225, 40, 21 ) ); 
     tuner_lab3->setText( tr( "Pitch" ) );
 
     tuner_pic1 = new QLabel( Tuner, "tuner_pic1" );
     tuner_pic1->setGeometry( QRect( 195, 155, 31, 31 ) ); 
     tuner_pic1->setFrameShape( QLabel::NoFrame );
     tuner_pic1->setPixmap( image6 );
     tuner_pic1->setScaledContents( TRUE );
     tabs->insertTab( Tuner, tr( "Tuner" ) );
 
     tab_3 = new QWidget( tabs, "tab_3" );
 
     chordlistlab1 = new QLabel( tab_3, "chordlistlab1" );
     chordlistlab1->setGeometry( QRect( 5, 5, 216, 16 ) );
     chordlistlab1->setText( tr( "Chord list" ) );
 
     chordlist = new QListBox( tab_3, "chordlist" );
     chordlist->setGeometry( QRect( 5, 25, 220, 200 ) );
 
     list_remove_btn = new QPushButton( tab_3, "list_remove_btn" );
     list_remove_btn->setGeometry( QRect( 150, 230, 71, 25 ) );
     list_remove_btn->setText( tr( "Remove" ) );
     tabs->insertTab( tab_3, tr( "Chords" ) );
 
     // hope this does what it's supposed to!!
     //    setPalette( QPalette( QColor( 232, 227, 215) ) );
     
     // signals and slots connections
 
     //cxm
     connect( tuning, SIGNAL( activated(int) ), frets, SLOT( Tune(int) ) );
     connect( span, SIGNAL( activated(int) ), frets, SLOT( Span(int) ) );
     connect( transport_rec, SIGNAL( clicked() ), this, SLOT( transport_rec_cb() ));
     connect( play_sound, SIGNAL( clicked() ), this, SLOT( play_chord_cb() ));
     connect( tuner_start, SIGNAL( clicked() ), this, SLOT( tuner_start_cb() ));
     connect( tuner_note, SIGNAL( textChanged(const QString&) ), vu, SLOT( AnnotL(const QString&) ));
     connect( this, SIGNAL( frequency_change(int) ), vu, SLOT( Value(int) ));
 
     connect( chordnote, SIGNAL( activated(int) ), frets, SLOT( Base(int) ) );
     connect( chordkey, SIGNAL( activated(int) ), frets, SLOT( Chord(int) ) );
     connect( chordfret, SIGNAL( activated(int) ), frets, SLOT( Fret(int) ) );
     connect( list_remove_btn, SIGNAL( clicked() ), this, SLOT( list_remove_cb() ) );
     connect( frets, SIGNAL( s1nameChanged(const QString&) ), s1_1, SLOT( setText(const QString&) ) );
     connect( frets, SIGNAL( s2nameChanged(const QString&) ), s1_2, SLOT( setText(const QString&) ) );
     connect( frets, SIGNAL( s3nameChanged(const QString&) ), s1_3, SLOT( setText(const QString&) ) );
     connect( frets, SIGNAL( s4nameChanged(const QString&) ), s1_4, SLOT( setText(const QString&) ) );
     connect( frets, SIGNAL( s5nameChanged(const QString&) ), s1_5, SLOT( setText(const QString&) ) );
     connect( frets, SIGNAL( s6nameChanged(const QString&) ), s1_6, SLOT( setText(const QString&) ) );
     connect( frets, SIGNAL( nameChanged(const QString&) ), chordname, SLOT( setText(const QString&) ) );
 }
 
 
 static int known=0;
 #include <qmessagebox.h>
 void PowerchordBase::transport_rec_cb(){
   chordlist->insertItem(chordname->text(),-1);
   if (!known){
     QMessageBox::information(this, "Powerchord", "This chord has been saved\ninto the list of chords,\nfor later playback.");
     known = 1;
   }
 }
 void PowerchordBase::list_remove_cb(){
   if (chordlist->count() > 0){
     chordlist->removeItem(0);
   }
 }
 void PowerchordBase::play_chord_cb(){
   //    QMessageBox::information(this, "Coming soon!", "This button plays\nthe chord by synthesizing\nthe sound of the notes.");
 
 
     if (audio_timer){
       audio_timer->stop();
       // set pixmap?
       synth->Stop();
       delete(audio_timer);
       audio_timer = 0;
     }else{
       // get notes from chord engine
       
       int note;
       int base;
       int octave;
       note = frets->ce.noteindex(0);
       if (note >= 0){
                 //fprintf(stderr, "Note was %d\n", note);
         base = note % 12;
         octave = note / 12;
         synth->note_start(0, base, octave);
       }else{
         // subtle bug here - replay second note if 1st one muted
         note = frets->ce.noteindex(1);
         base = note % 12;
         octave = note / 12;
         synth->note_start(1, base, octave);
 
       }
 
       // init synth
       if (synth->Play()){
         // error
         QMessageBox::information(this, "Powerchord", "Unable to open device for sound playback - check that no other application is using it.");
         return;
       }
       synth->fill_buffer();
       
       // start timer
       audio_timer = new QTimer();
       connect(audio_timer, SIGNAL( timeout() ), this, SLOT( audio_cb() ));
       // set pixmap on player?
       audio_timer->start(19); // 19 msec (fudge factor!!)
     }
 }
 
 
 
 void PowerchordBase::audio_cb(){
   // play the next bit of audio until quiet
 
   // strum timing
 #define INTERVAL 2
 
   if ((synth->Frames() % INTERVAL) == 0){
     int string = synth->Frames() / INTERVAL;
     if (string <= 5){
       int note;
       int base;
       int octave;
       note = frets->ce.noteindex(string);
       // check not muted...
       if (note > 0){
         base = note % 12;
         octave = note / 12;
         synth->note_start(string, base, octave);
       }
     }
   }
   
   if (synth->Playing()){
     synth->write_buffer();
     synth->fill_buffer();
   }else{
     audio_timer->stop();
     // set pixmap?
     synth->Stop();
     delete(audio_timer);
     audio_timer = 0;
   }
 }
 
 // the real tuner
 //  void PowerchordBase::tuner_start_cb(){
 
 //    if (tuner->Listening()){
 //      simulation_timer->stop();
 //      tuner->Stop();
 //      tuner_pic1->setPixmap( *image6 );
     
 //    }else{
 //      tuner_pic1->setPixmap( *image_open );
     
 //      if (!simulation_timer){
 //        simulation_timer = new QTimer();
       
       
 //        connect(simulation_timer, SIGNAL( timeout() ), this, SLOT( tuner_cb() ));
 //      }
     
 //      simulation_timer->start(50);
 //      tuner->Listen();
     
 //    }  
 //  }
 
 void PowerchordBase::tuner_cb(){
   if (tuner->Listening()){
     tuner->read_buffer();
     tuner->process_buffer();
     
     // update gui
     // do something with the note: tuner->Note()
     emit frequency_change(tuner->Tuning());
     
   }else{
     simulation_timer->stop();
     tuner->Stop();
     tuner_pic1->setPixmap( image6 );
   }
 }
 
 
 void PowerchordBase::tuner_start_cb(){
   if (0 == QMessageBox::information(this, "Powerchord", "Using the microphone,\nthe note's frequency\nis analysed. This\nis a simulation.", "OK", "Cancel", 0, 1)){
     if (simulation_timer){
       simulation_timer->stop();
     }else{
       simulation_timer = new QTimer();
       connect(simulation_timer, SIGNAL( timeout() ), this, SLOT( tuner_simulation_cb() ));
       
     }
     simulation_x = -45;
     simulation_v = 0;
     simulation_iter = 0;
 
     tuner_pic1->setPixmap( image_open );
     simulation_timer->start(100);
   }
 }
 
 #include <stdio.h>
 
 void PowerchordBase::tuner_simulation_cb(){
   if (simulation_x < -10 || simulation_x > 10){
     simulation_v = (simulation_v/2)-(simulation_x/5);
   }
   
   simulation_x += simulation_v;
   simulation_iter++;
 
   if (simulation_x > 50){
     simulation_x = 50;
   }
 
   if (simulation_x < -50){
     simulation_x = -50;
   }
 
   if (simulation_iter > 50){
     simulation_timer->stop();
     emit frequency_change(0);
     tuner_pic1->setPixmap( image6 );
   }else{
     emit frequency_change(simulation_x);
   }
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 PowerchordBase::~PowerchordBase()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 void PowerchordBase::change_handler()
 {
     qWarning( "PowerchordBase::change_handler(): Not implemented yet!" );
 }
 
diff --git a/noncore/multimedia/showimg/ImageFileSelector.cpp b/noncore/multimedia/showimg/ImageFileSelector.cpp
index d2b65a9..79ee925 100644
--- a/noncore/multimedia/showimg/ImageFileSelector.cpp
+++ b/noncore/multimedia/showimg/ImageFileSelector.cpp
@@ -1,271 +1,260 @@
 
 
-#include "qpe/global.h"
-#include "qpe/applnk.h"
-#include "qpe/lnkproperties.h"
-#include "qpe/applnk.h"
 #include "qpe/qpeapplication.h"
 
 #include <stdlib.h>
 
-#include <qdir.h>
-#include <qwidget.h>
-#include <qheader.h>
-#include <qimage.h>
-#include <qpixmap.h>
 #include <qlabel.h>
 #include <qfileinfo.h>
-#include <qpainter.h>
-#include <qscrollview.h>
 
 #include "ImageFileSelector.h"
 
 
 ThumbWidget::ThumbWidget(QPixmap p,QString text,const DocLnk& f,QWidget *parent,int w)
         : QWidget( parent ),fl(f)
 {
     setBackgroundMode(NoBackground);  
     if ( w!=-1 )
         setMinimumSize(w,p.height()+24);
     else
         setMinimumSize(p.width(),p.height()+24);
     description=new QLabel(text,this);
     description->setBackgroundColor(colorGroup().base());
     description->setAlignment(AlignCenter);
     description->setGeometry(0,height()-24,width(),24);
     pixmap=p;
 }
 
 void ThumbWidget::resizeEvent(QResizeEvent *)
 {
     description->setGeometry(0,height()-24,width(),24);
 }
 
 void ThumbWidget::paintEvent( QPaintEvent *e )
 {
     QPainter painter(this);
 
     painter.setClipRect(e->rect());
     painter.fillRect(0,0,width(),height(),QColor(255,255,255));
     painter.drawPixmap((width() - pixmap.width()) / 2,0, pixmap);
 
 }
 
 void ThumbWidget::mouseReleaseEvent(QMouseEvent* )
 {
     emit clicked(fl);
 }
 
 
 
 ImageFileSelectorItem::ImageFileSelectorItem( QListView *parent, const DocLnk &f)
         : QListViewItem( parent ), fl( f )
 {
     setText( 0, f.name() );
     QFileInfo fi(f.file());
     setText( 1, (fi.extension()).upper() );
     setPixmap( 0, f.pixmap() );
 
 
 }
 
 
 ImageFileSelectorItem::~ImageFileSelectorItem()
 {
     
 }
 
 
 ImageFileSelector::ImageFileSelector( CURRENT_VIEW scv,QWidget *parent,const char * )
         : QWidgetStack(parent)
 {
 
     detailed=new QListView(this);
 
     detailed->addColumn (tr("Title")); 
     detailed->addColumn (tr("Type")); 
     detailed->setAllColumnsShowFocus( true );
 
     tList.setAutoDelete(true);
 
     thumb =new QScrollView(this);
     thumb->setVScrollBarMode (QScrollView::Auto );
     thumb->viewport()->setBackgroundColor(colorGroup().base());
 
     background=new QWidget(0);
     background->setBackgroundColor(colorGroup().base());
     thumb->addChild(background);
     gl = new QGridLayout(background,1,2,4,4);
 
 
 
     connect( detailed, SIGNAL( mouseButtonClicked(int,QListViewItem*,const QPoint&,int) ),
              this, SLOT( fileClicked(int,QListViewItem*,const QPoint&,int) ) );
     connect( detailed, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ),
              this, SLOT( filePressed(int,QListViewItem*,const QPoint&,int) ) );
     connect( detailed, SIGNAL( returnPressed(QListViewItem*) ),
              this, SLOT( fileClicked(QListViewItem*) ) );
 
     cView=UNKNOWN;
     setView(scv);
     reread();    
 
 }
 ImageFileSelector::~ImageFileSelector()
 {
     
 }
 
 
 void ImageFileSelector::switchView()
 {
     CURRENT_VIEW v=cView;
 
     if ( v==DETAILED )
         v=THUMBNAIL;
     else
         v=DETAILED;
     setView(v);
 }
 
 void ImageFileSelector::setView(CURRENT_VIEW v)
 {
 
     if ( v==cView )
         return;
     cView=v;
 
     if ( cView!=DETAILED )
     {
         raiseWidget(thumb);            
         updateSizes();
     }
     else
     {
         raiseWidget(detailed);              
         updateSizes();
     }
 
 
 }
 
 void ImageFileSelector::resizeEvent(QResizeEvent *)
 {
     updateSizes();
 }
 
 void ImageFileSelector::updateSizes()
 {
     int ww=(detailed->width()-detailed->frameWidth()*2);
     double w=(double)ww*0.70;
     detailed->setColumnWidth(0,(int)w);
     detailed->setColumnWidth(1,ww-(int)w);
     background->setMinimumWidth(thumb->visibleWidth());
     thumb->updateScrollBars(); 
 }
 
 void ImageFileSelector::reread(bool)
 {
 //    qDebug("reread");
     ImageFileSelectorItem *item = (ImageFileSelectorItem *)detailed->selectedItem();
     QString oldFile;
     if ( item )
         oldFile = item->file().file();
     detailed->clear();
     tList.clear();
     DocLnkSet files;
     Global::findDocuments(&files, "image/*");
     count = files.children().count();
     QListIterator<DocLnk> dit( files.children() );
 //    int y=0;
 //    int x=4;
 //    int totalHeight=4;
     ThumbWidget *l=0;
     int width=80;
     gl->expand(dit.count()/2,2);
     int i,j;
     i=j=0;
     detailed->setUpdatesEnabled(false);
     thumb->setUpdatesEnabled(false);
 
     for ( ; dit.current(); ++dit ) {
         item = new ImageFileSelectorItem( detailed, **dit );        
         if ( item->file().file() == oldFile )
             detailed->setCurrentItem( item );
     }
 
     QListViewItemIterator it( detailed );
     ImageFileSelectorItem *ii;
       // iterate through all items of the listview
     for ( ; it.current(); ++it ) {
         ii=(ImageFileSelectorItem *)it.current();
         QImage img( ii->file().file() );
         if( !img.isNull()) {
             img=img.smoothScale(64,64);
             QPixmap pix;
             pix.convertFromImage(img);                
             l=new ThumbWidget(pix,ii->file().name(),ii->file(),background,width);
             l->setBackgroundColor(colorGroup().base());        
             gl->addWidget(l,j,i);
             i++;
             if ( i==2 ) {
                 i=0;
                 j++;
             }
             tList.append(l);
             connect(l,SIGNAL(clicked(const DocLnk&)),this,SLOT(thumbClicked(const DocLnk&)));
         }
     }
 
     if ( !detailed->selectedItem() )
         detailed->setCurrentItem( detailed->firstChild() );
 
     detailed->setUpdatesEnabled(true);
     thumb->setUpdatesEnabled(true);
     detailed->update();
     thumb->update();
 }
 
 int ImageFileSelector::fileCount()
 {
     return count;
 }
 const DocLnk * ImageFileSelector::selected()
 {
     qDebug("image selected");
     ImageFileSelectorItem *item = (ImageFileSelectorItem *) detailed->selectedItem();
     if ( item )
         return new DocLnk( item->file() );
     return 0;
 }
 
 
 
 void ImageFileSelector::fileClicked( int button, QListViewItem *i, const QPoint &, int )
 {
     if ( !i )
         return;
     if ( button == Qt::LeftButton )
     {
         fileClicked( i );
     }
 }
     // pressed to get 'right down'
 void ImageFileSelector::filePressed( int, QListViewItem *, const QPoint &, int )
 {
     
 }
 void ImageFileSelector::fileClicked( QListViewItem *i)
 {
     if ( !i )
         return;
     emit fileSelected( ( (ImageFileSelectorItem*)i )->file() );
     emit closeMe();     
 }
 
 void ImageFileSelector::thumbClicked(const DocLnk &f)
 {
     emit fileSelected( f );
     emit closeMe();     
 }
 
diff --git a/noncore/multimedia/showimg/main.cpp b/noncore/multimedia/showimg/main.cpp
index efb1c68..1c864e9 100644
--- a/noncore/multimedia/showimg/main.cpp
+++ b/noncore/multimedia/showimg/main.cpp
@@ -1,27 +1,26 @@
 /**********************************************************************
 ** 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 "showimg.h"
 
-#include <qpe/qpeapplication.h>
 
 #include <opie/oapplicationfactory.h>
 
 OPIE_EXPORT_APP( OApplicationFactory<ImageViewer> )
\ No newline at end of file
diff --git a/noncore/multimedia/showimg/settingsdialog.cpp b/noncore/multimedia/showimg/settingsdialog.cpp
index 55d555a..202bd0c 100644
--- a/noncore/multimedia/showimg/settingsdialog.cpp
+++ b/noncore/multimedia/showimg/settingsdialog.cpp
@@ -1,88 +1,86 @@
 /**********************************************************************
 ** 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 "settingsdialog.h"
 #include <qslider.h>
 #include <qlabel.h>
 #include <qcheckbox.h>
-#include <qradiobutton.h>
-#include <qbuttongroup.h>
 
 SettingsDialog::SettingsDialog( QWidget *parent, const char *name, bool modal, WFlags f )
     : SettingsDialogBase( parent, name, modal, f )
 {
     connect( delaySlider, SIGNAL(valueChanged(int)), this, SLOT(delayChanged(int)) );
 }
 
 void SettingsDialog::setDelay( int d )
 {
     delaySlider->setValue( d );
     delayChanged( d );
 }
 
 int SettingsDialog::delay() const
 {
     return delaySlider->value();
 }
 
 void SettingsDialog::setRepeat( bool r )
 {
     repeatCheck->setChecked( r );
 }
 
 bool SettingsDialog::repeat() const
 {
     return repeatCheck->isChecked();
 }
 
 void SettingsDialog::delayChanged( int d )
 {
     delayText->setText( QString::number( d ) + " s" );
 }
 
 void SettingsDialog::setReverse(bool r)
 {
     reverseCheck->setChecked(r);
 }
 
 bool SettingsDialog::reverse() const
 {
     return reverseCheck->isChecked();
 }
 
 void SettingsDialog::setRotate(bool r)
 {
     rotateCheck->setChecked(r);
 }
 
 bool SettingsDialog::rotate() const
 {
     return rotateCheck->isChecked();
 }
 
 void SettingsDialog::setFastLoad(bool f)
 {
     fastLoadCheck->setChecked(f);
 }
 
 bool SettingsDialog::fastLoad() const
 {
     return fastLoadCheck->isChecked();
 }
diff --git a/noncore/multimedia/showimg/settingsdialogbase.cpp b/noncore/multimedia/showimg/settingsdialogbase.cpp
index e0c5bb0..7a64e89 100644
--- a/noncore/multimedia/showimg/settingsdialogbase.cpp
+++ b/noncore/multimedia/showimg/settingsdialogbase.cpp
@@ -1,106 +1,102 @@
 /****************************************************************************
 ** Form implementation generated from reading ui file 'settingsdialogbase.ui'
 **
 ** Created: Sun Nov 3 07:29:03 2002
 **      by:  The User Interface Compiler (uic)
 **
 ** WARNING! All changes made in this file will be lost!
 ****************************************************************************/
 #include "settingsdialogbase.h"
 
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qlabel.h>
-#include <qpushbutton.h>
 #include <qslider.h>
 #include <qlayout.h>
-#include <qvariant.h>
-#include <qtooltip.h>
-#include <qwhatsthis.h>
 
 /* 
  *  Constructs a SettingsDialogBase which is a child of 'parent', with the 
  *  name 'name' and widget flags set to 'f' 
  *
  *  The dialog will by default be modeless, unless you set 'modal' to
  *  TRUE to construct a modal dialog.
  */
 SettingsDialogBase::SettingsDialogBase( QWidget* parent,  const char* name, bool modal, WFlags fl )
     : QDialog( parent, name, modal, fl )
 {
     if ( !name )
         setName( "SettingsDialogBase" );
     resize( 246, 201 ); 
     setCaption( tr( "Preferences" ) );
     SettingsDialogBaseLayout = new QVBoxLayout( this ); 
     SettingsDialogBaseLayout->setSpacing( 6 );
     SettingsDialogBaseLayout->setMargin( 6 );
 
     GroupBox1 = new QGroupBox( this, "GroupBox1" );
     GroupBox1->setTitle( tr( "Slide Show" ) );
     GroupBox1->setColumnLayout(0, Qt::Vertical );
     GroupBox1->layout()->setSpacing( 0 );
     GroupBox1->layout()->setMargin( 0 );
     GroupBox1Layout = new QVBoxLayout( GroupBox1->layout() );
     GroupBox1Layout->setAlignment( Qt::AlignTop );
     GroupBox1Layout->setSpacing( 6 );
     GroupBox1Layout->setMargin( 11 );
 
     Layout3 = new QGridLayout; 
     Layout3->setSpacing( 6 );
     Layout3->setMargin( 0 );
 
     TextLabel1 = new QLabel( GroupBox1, "TextLabel1" );
     TextLabel1->setText( tr( "Delay between pictures" ) );
 
     Layout3->addMultiCellWidget( TextLabel1, 0, 0, 0, 1 );
 
     delaySlider = new QSlider( GroupBox1, "delaySlider" );
     delaySlider->setMinValue( 2 );
     delaySlider->setMaxValue( 60 );
     delaySlider->setLineStep( 2 );
     delaySlider->setOrientation( QSlider::Horizontal );
     delaySlider->setTickmarks( QSlider::Right );
     delaySlider->setTickInterval( 10);
 
     Layout3->addWidget( delaySlider, 1, 0 );
 
     delayText = new QLabel( GroupBox1, "delayText" );
     delayText->setMinimumSize( QSize( 25, 0 ) );
     delayText->setText( tr( "s" ) );
     delayText->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) );
 
     Layout3->addWidget( delayText, 1, 1 );
     GroupBox1Layout->addLayout( Layout3 );
 
     repeatCheck = new QCheckBox( GroupBox1, "repeatCheck" );
     repeatCheck->setText( tr( "Repeat slideshow" ) );
     GroupBox1Layout->addWidget( repeatCheck );
 
     reverseCheck = new QCheckBox( GroupBox1, "reverseCheck" );
     reverseCheck->setText( tr( "Show pictures in reverse" ) );
     GroupBox1Layout->addWidget( reverseCheck );
     SettingsDialogBaseLayout->addWidget( GroupBox1 );
 
     rotateCheck = new QCheckBox( this, "rotateCheck" );
     rotateCheck->setText( tr( "Load pictures rotated 90 degrees" ) );
     SettingsDialogBaseLayout->addWidget( rotateCheck );
 
     fastLoadCheck = new QCheckBox( this, "fastLoadCheck" );
     fastLoadCheck->setText( tr( "Fast load pictures" ) );
     SettingsDialogBaseLayout->addWidget( fastLoadCheck );
     fastLoadCheck->hide(); //FIXME
 //    QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Expanding );
 //    layout->addItem( spacer, 10, 0 );
 
     
 }
 
 /*  
  *  Destroys the object and frees any allocated resources
  */
 SettingsDialogBase::~SettingsDialogBase()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
diff --git a/noncore/multimedia/showimg/showimg.cpp b/noncore/multimedia/showimg/showimg.cpp
index 02a1d91..82eac33 100644
--- a/noncore/multimedia/showimg/showimg.cpp
+++ b/noncore/multimedia/showimg/showimg.cpp
@@ -1,1251 +1,1238 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 
 //
 // Full-screen and rotation options contributed by Robert Wittams <robert@wittams.com>
 //
 
 #include "showimg.h"
 #include "ImageFileSelector.h"
 #include "settingsdialog.h"
 
 
 #include <opie/ofiledialog.h>
 
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include <qpe/resource.h>
-#include <qpe/fileselector.h>
-#include <qpe/applnk.h>
-#include <qfileinfo.h>
 #include <math.h>
 #include <qmenubar.h>
-#include <qwidgetstack.h>
 #include <qpe/qpetoolbar.h>
 #include <qaction.h>
 #include <qfiledialog.h>
-#include <qmessagebox.h>
-#include <qpopupmenu.h>
-#include <qscrollview.h>
-#include <qlabel.h>
-#include <qpainter.h>
-#include <qkeycode.h>
-#include <qapplication.h>
-#include <qclipboard.h>
-#include <qtimer.h>
 #include <qspinbox.h>
 
 
 
 ControlsDialog::ControlsDialog(const QString &caption,QImage image,int *brightness,QWidget *parent)
         : QDialog(parent,0,true)
 {
     setCaption(caption);
 
     if ( parent )  {
         setPalette(parent->palette());
     }
 
     b=brightness;
     img=image;
 
     setMinimumSize(140,80);
 
     QGridLayout  *gl= new QGridLayout(this,2,2,4,4);
 
     pixmap =new ImageWidget(this);;
     QPixmap pm;
     pm.convertFromImage(img);
     pixmap->setPixmap(pm);
     pixmap->setMinimumSize(pm.width(),pm.height());
     gl->addMultiCellWidget(pixmap,0,0,0,2,AlignCenter);
     QLabel *l=new QLabel(tr("Brightness")+":",this);
     gl->addWidget(l,1,0,AlignLeft);
     spb=new QSpinBox(-100,100,2,this);
     gl->addWidget(spb,1,1,AlignRight);
 
     spb->setValue(0);
 
     connect(spb,SIGNAL(valueChanged(int)),this, SLOT(bValueChanged(int)));
 
 }
 
 void ControlsDialog::bValueChanged(int value)
 {
     QImage nImage=img;
     nImage.detach();
     ImageViewer::intensity(nImage, (float)value/100);
     QPixmap pm;
     pm.convertFromImage(nImage);
     pixmap->setPixmap(pm);
     pixmap->repaint(false);
 
 
 }
 
 void ControlsDialog::accept()
 {
     *b=spb->value();
     done(1);
 }
 
 //===========================================================================
 
 InfoDialog::InfoDialog(const QString &caption, const QStringList text,QWidget *parent)
         : QDialog(parent,0,true)
 {
     setCaption(caption);
 
     if ( parent )
     {
         setPalette(parent->palette());
     }
 
 
 
     QString labels[]={ tr("File Name"),tr("Format"),tr("File Size"),tr("Size"),tr("Colors"),tr("Alpha") };
 
     setMinimumSize(180,80);
     int num=ImageViewer::LAST+1;
     if ( text[ImageViewer::ALPHA].isEmpty() )
         num--;
     QGridLayout  *gl= new QGridLayout(this,num,2,4,2);
     QLabel *l;
     int count=0;
     for ( int i=0;i<num;i++ )
     {
         if ( i==1 )
         {
             QFrame *frm=new QFrame(this);
             frm->setFrameStyle(QFrame::HLine|QFrame::Sunken);
             gl->addMultiCellWidget(frm,i,i,0,1);
         }
         else
         {
             l=new QLabel( tr(  labels[count]  )+":",this);
             gl->addWidget(l,i,0,AlignLeft);
             l=new QLabel(text[count],this);
             gl->addWidget(l,i,1,AlignRight);
             count++;
         }
 
     }
 
 }
 
 void InfoDialog::displayInfo(const QString &caption, const QStringList text, QWidget *parent)
 {
     InfoDialog *dlg=new InfoDialog(caption,text,parent);
     dlg->exec();
     delete dlg;
 }
 
 //===========================================================================
 
 
 ImagePane::ImagePane( QWidget *parent ) : QWidget( parent )
 {
     vb = new QVBoxLayout( this );
 
     image = new QScrollView(this,0,WResizeNoErase|WNorthWestGravity);
     pic=new ImageWidget(image);
     image->addChild(pic);
 
     connect(pic, SIGNAL( clicked() ), this, SLOT( imageClicked() ));
 
     vb->addWidget( image );
 
 }
 
 void ImagePane::setPixmap( const QPixmap &pm )
 {
     pic->setPixmap( pm );
     pic->resize(pm.width(),pm.height());
     image->updateScrollBars ();
     pic->repaint(false);
 }
 
 void ImagePane::imageClicked()
 {
     emit clicked();
 }
 //===========================================================================
 /*
   Draws the portion of the scaled pixmap that needs to be updated
 */
 
 void ImageWidget::paintEvent( QPaintEvent *e )
 {
     QPainter painter(this);
 
     painter.setClipRect(e->rect());
     painter.fillRect(0,0,width(),height(),QColor(0,0,0));
 
     if ( pixmap.size() != QSize( 0, 0 ) )
     { // is an image loaded?
         painter.drawPixmap((width() - pixmap.width()) / 2, (height() - pixmap.height()) / 2, pixmap);
     }
 }
 
 void ImageWidget::mouseReleaseEvent(QMouseEvent *)
 {
     emit clicked();
 }
 
 //===========================================================================
 
 ImageViewer::ImageViewer( QWidget *parent, const char *name, int wFlags )
 : QMainWindow( parent, name, WResizeNoErase ), filename( 0 ),  bFromDocView( FALSE )
 {
     setCaption( tr("Image Viewer") );
     setIcon( Resource::loadPixmap( "ImageViewer" ) );
 
 
     Config cfg("Image Viewer");
     cfg.setGroup("Image Viewer");
 
     showThumbView=cfg.readBoolEntry("ShowThumbnails",false);
     isSized=cfg.readBoolEntry("SizeToScreen",true);
 
     isFullScreen = FALSE;
 
     setToolBarsMovable( FALSE );
 
     toolBar = new QToolBar( this );
     toolBar->setHorizontalStretchable( TRUE );
 
     menuBar = new QMenuBar( toolBar );
 
     current=menuBar;
 
 
 
     fileMenuFile = new QPopupMenu(this);
     //menuBarmenubarFile->insertItem( tr("File"), fileMenu );
     fileMenuFile->insertItem(tr("Open"),
                             this, SLOT(openFile()), 0);
 
     viewMenuFile = new QPopupMenu( this );
     //menubarFile->insertItem( tr("View"), viewMenu );
     viewMenuFile->insertItem( tr("Thumbnail View"),
                               this, SLOT(switchThumbView()), 0, SHOW_THUMBNAILS );
 
     viewMenuFile->setItemChecked ( SHOW_THUMBNAILS, showThumbView );
 
 
 
 
     optionsMenuFile = new QPopupMenu( this);
     //menubarFile->insertItem( tr("Options"),optionsMenu );
     slideAction = new QAction( tr( "Slide show" ), Resource::loadIconSet( "slideshow" ),
                                QString::null, 0, this, 0 );
     slideAction->setToggleAction( TRUE );
     connect( slideAction, SIGNAL( toggled(bool) ), this, SLOT( slideShow(bool) ) );
     slideAction->addTo( optionsMenuFile);
 //     slideAction->addTo( toolBar );
 
 
 //     optionsMenuFile->insertItem( tr("Slideshow") );
     optionsMenuFile->insertSeparator();
     optionsMenuFile->insertItem( tr("Preferences.."), this, SLOT(settings()), 0);
 //    optionsMenuFile->insertItem( tr("Help"), this, SLOT(help()), 0);
 
     QStrList fmt = QImage::outputFormats();
 
 
     fileMenuView = new QPopupMenu( this );
     //menubarView->insertItem( tr("File"),fileMenu );
     fileMenuView->insertItem( tr("Image Info ..."),this, SLOT(displayInfoDialog()),0 );
     fileMenuView->insertSeparator();
 
     viewMenuView = new QPopupMenu(this );
     viewMenuView->setCheckable ( true );
 
     //menubarView->insertItem( tr("View"),viewMenu );
     viewMenuView->insertItem(tr("Horizontal flip"), this, SLOT(hFlip()), 0);
     viewMenuView->insertItem(tr("Vertical flip"), this, SLOT(vFlip()), 0);
 
     stack = new QWidgetStack( this );
     stack->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
     setCentralWidget( stack );
 
 
     imagePanel = new ImagePane( stack );
     connect(imagePanel, SIGNAL(clicked()), this, SLOT(normalView()));
 
 
     ImageFileSelector::CURRENT_VIEW cv;
     if(showThumbView)
         cv=ImageFileSelector::THUMBNAIL;
     else
         cv=ImageFileSelector::DETAILED;
 
     qDebug("cv = %d",cv);
 
     fileSelector = new ImageFileSelector( cv,stack, "fs");
 
     //switchThumbView();
 
 
     //fileSelector = new ImageFileSelector("image/*", stack, "fs");
     //fileSelector->setNewVisible(FALSE);
     //fileSelector->setCloseVisible(FALSE);
     connect( fileSelector, SIGNAL( closeMe() ), this, SLOT( closeFileSelector() ) );
     connect( fileSelector, SIGNAL( fileSelected(const DocLnk&) ),
              this, SLOT( openFile(const DocLnk&) ) );
 
     imageList = fileSelector->fileList();
     slideAction->setEnabled( imageList.count() != 0);
 
     iconToolBar = new QToolBar(this);
 
     QAction *a;
 
     a = new QAction( tr( "Open ..." ), Resource::loadPixmap( "fileopen" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( open() ) );
     a->addTo( fileMenuView);
     a->addTo( iconToolBar );
 
 
     a = new QAction( tr( "Rotate 90"), Resource::loadPixmap( "rotate90" ), QString::null, 0, this, 0);
     connect( a, SIGNAL( activated() ), this, SLOT( rot90() ) );
     a->addTo( iconToolBar );
     a->addTo( viewMenuView );
 
     a = new QAction( tr( "Rotate 180" ), Resource::loadPixmap( "repeat" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( rot180() ) );
     a->addTo( iconToolBar );
     a->addTo( viewMenuView );
 
 
     a = new QAction( tr( "Rotate 270"), Resource::loadPixmap( "rotate270" ), QString::null, 0, this, 0);
     connect( a, SIGNAL( activated() ), this, SLOT( rot270() ) );
     //a->addTo( iconToolBar );
     a->addTo( viewMenuView );
 
 
 
     viewMenuView->insertSeparator();
     viewMenuView->insertItem(tr("Brightness ..."), this, SLOT(displayControlsDialog()), 0);
     viewMenuView->insertItem(tr("Black And White"), this, SLOT(blackAndWhite()), 0,BLACKANDWHITE);
     viewMenuView->insertSeparator();
 
 
     sss = new QAction( tr( "Scale to Screen"), Resource::loadPixmap( "scale" ), QString::null, 0, this, 0,true);
     connect( sss, SIGNAL( activated() ), this, SLOT( switchSizeToScreen() ) );
     sss->addTo( iconToolBar );
     sss->addTo( viewMenuView );
 
     sss->setOn(isSized);
     viewMenuView->insertSeparator();
 
 
     a = new QAction( tr( "Fullscreen" ), Resource::loadPixmap( "fullscreen" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fullScreen() ) );
     a->addTo( iconToolBar );
     a->addTo( viewMenuView);
 
     a = new QAction( tr( "Stop Slideshow" ), Resource::loadPixmap( "quit_icon" ),
                      QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( stopSlideShow() ) );
     a->addTo( iconToolBar );
     a->addTo( viewMenuView);
 
 
     Config config( "ImageViewer" );
     config.setGroup( "SlideShow" );
     slideDelay = config.readNumEntry( "Delay", 2);
     slideRepeat = config.readBoolEntry( "Repeat", FALSE );
     slideReverse = config.readBoolEntry("Reverse", FALSE);
 
     config.setGroup("Default");
     rotateOnLoad = config.readBoolEntry("Rotate", FALSE);
     fastLoad = config.readBoolEntry("FastLoad", TRUE);
     slideTimer = new QTimer( this );
     connect( slideTimer, SIGNAL(timeout()), this, SLOT(slideUpdate()) );
 
     switchToFileSelector();
 
     setMouseTracking( TRUE );
 
 
 }
 
 ImageViewer::~ImageViewer()
 {
     Config cfg("Image Viewer");
     cfg.setGroup("Image Viewer");
 
     cfg.writeEntry("ShowThumbnails",(int)showThumbView);
     cfg.writeEntry("SizeToScreen",(int)isSized);
 
     cfg.setGroup( "SlideShow" );
     cfg.writeEntry( "Delay", slideDelay);
     cfg.writeEntry( "Repeat", slideRepeat );
     cfg.writeEntry("Reverse",  slideReverse);
 
     cfg.setGroup("Default");
     cfg.writeEntry("Rotate", rotateOnLoad);
     cfg.writeEntry("FastLoad", fastLoad);
 
     delete imagePanel; // in case it is fullscreen
 }
 
 void ImageViewer::help() {
 
 }
 
 
 void ImageViewer::settings()
 {
     SettingsDialog dlg( this, 0, TRUE );
     dlg.setDelay( slideDelay );
     dlg.setRepeat( slideRepeat );
     dlg.setReverse( slideReverse );
     dlg.setRotate(rotateOnLoad);
     dlg.setFastLoad(fastLoad);
 
     if ( QPEApplication::execDialog(&dlg) == QDialog::Accepted ) {
         qDebug("<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>");
         slideDelay = dlg.delay();
         slideRepeat = dlg.repeat();
         slideReverse = dlg.reverse();
         rotateOnLoad = dlg.rotate();
         fastLoad = dlg.fastLoad();
 
         Config config( "ImageViewer" );
         config.setGroup( "SlideShow" );
         config.writeEntry( "Delay", slideDelay );
         config.writeEntry( "Repeat", slideRepeat );
         config.writeEntry("Reverse", slideReverse);
 
         config.setGroup("Default");
         config.writeEntry("Rotate", rotateOnLoad);
         config.writeEntry("FastLoad", fastLoad);
     }
 }
 
 void ImageViewer::switchSizeToScreen()
 {
     isSized=!isSized;
     sss->setOn(isSized);
     updateImage();
 }
 
 void ImageViewer::updateImage()
 {
     if ( isSized ) {
         imagePanel->setPixmap(pmScaled);
     } else {
         imagePanel->setPixmap(pm);
     }
 }
 
 void ImageViewer::switchThumbView()
 {
 
     showThumbView=!showThumbView;
     viewMenuFile->setItemChecked ( SHOW_THUMBNAILS, showThumbView );
     fileSelector->switchView();
 
 }
 
 void ImageViewer::switchToFileSelector()
 {
     stack->raiseWidget(fileSelector);
     menuBar->clear();
     menuBar->insertItem( tr("File"), fileMenuFile );
     menuBar->insertItem( tr("View"), viewMenuFile );
     menuBar->insertItem( tr("Options"), optionsMenuFile );
     iconToolBar->hide();
     imagePanel->disable();
     slideShow(false);
 
 }
 
 void ImageViewer::switchToImageView()
 {
     stack->raiseWidget(imagePanel);
 
     menuBar->clear();
     menuBar->insertItem( tr("File"), fileMenuView );
     menuBar->insertItem( tr("View"), viewMenuView );
     viewMenuView->setItemEnabled(BLACKANDWHITE,true);
     iconToolBar->show();
 
     imagePanel->setPosition(0,0);
 
 }
 
 
 void ImageViewer::setDocument(const QString& fileref)
 {
     delayLoad = fileref;
     switchToImageView();
     QTimer::singleShot( 0, this, SLOT(doDelayedLoad()) );
 }
 
 void ImageViewer::doDelayedLoad()
 {
     show(delayLoad);
 }
 
 void ImageViewer::show()
 {
     normalView();
     QMainWindow::show();
 }
 
 void ImageViewer::show(const QString& fileref)
 {
 //    qDebug("Show "+fileref);
     bFromDocView = TRUE;
     closeFileSelector();
     DocLnk link(fileref);
     if ( link.isValid() ) {
         openFile(link);
     } else {
         filename = fileref;
         updateCaption( fileref );
         loadImage( fileref );
     }
 }
 
 void ImageViewer::openFile() {
     MimeTypes types;
     QStringList image;
     image << "image/*";
     types.insert("Images",  image);
 
     QString str = OFileDialog::getOpenFileName( 1,QPEApplication::documentDir(),"", types, 0 );
     DocLnk link(str);
 //    if ( link.isValid() )
         openFile(link);
 
 }
 
 void ImageViewer::openFile( const DocLnk &link )
 {
     closeFileSelector();
 //    DocLnk link(file);
     qDebug("open "+link.name());
     updateCaption( link.name() );
     loadImage( link.file() );
     if (slideTimer->isActive()) {
         slideTimer->start(slideDelay * 1000, FALSE);
     }
 
 }
 
 void ImageViewer::open()
 {
     switchToFileSelector();
 }
 
 void ImageViewer::closeFileSelector()
 {
     switchToImageView();
 }
 
 void ImageViewer::updateCaption( QString name )
 {
     int sep = name.findRev( '/' );
     if ( sep >= 0 )
         name = name.mid( sep+1 );
     setCaption( name + tr(" - Image Viewer") );
 }
 
 /*
   This function loads an image from a file.
 */
 
 void ImageViewer::loadImage( const char *fileName )
 {
     filename = fileName;
     if ( filename )  {
         QApplication::setOverrideCursor( waitCursor ); // this might take time
         //imagePanel->statusLabel()->setText( tr("Loading image...") );
         qApp->processEvents();
         bool ok = image.load(filename, 0);
         if ( ok ) {
             ok = reconvertImage();
             updateImageInfo(filename);
         }
         if ( !ok ) {
             pm.resize(0,0);             // couldn't load image
             update();
         }
         QApplication::restoreOverrideCursor();  // restore original cursor
     }
 
 //    fastLoad ? ", Fast" : "",
 //    fastLoad ? QMAX(imagewidth/maxsize, imageheight/maxsize) : 1);
 
 
 //    matrix.reset();
     rotated90 = FALSE;
 
     if (rotateOnLoad) {
         rotated90 = TRUE;
         rot90();
 //        matrix.rotate( -90.0 );
     }
 
     switchToImageView();
     updateImage();
 
 }
 
 bool ImageViewer::loadSelected()
 {
     bool ok = false;
     if ( stack->visibleWidget() == fileSelector )
     {
         const DocLnk *link = fileSelector->selected();
         if ( link )
         {
             if ( link->file() != filename )
             {
                 updateCaption( link->name() );
                 filename = link->file();
                 qApp->processEvents();
                 ok = image.load(filename, 0);
                 if ( ok )
                 {
                     updateImageInfo(filename);
                     ok = reconvertImage();
                 }
                 if ( !ok )
                     pm.resize(0,0);
             }
         }
     }
     if ( !image.isNull() )
     {
         ok = true;
         closeFileSelector();
     }
 
     return ok;
 }
 
 bool ImageViewer::reconvertImage()
 {
     bool success = FALSE;
 
     if ( image.isNull() ) return FALSE;
 
     QApplication::setOverrideCursor( waitCursor ); // this might take time
     if ( pm.convertFromImage(image /*, conversion_flags */ ) )
     {
         pmScaled = QPixmap();
         scale();
         success = TRUE;             // load successful
     }
     else
     {
         pm.resize(0,0);             // couldn't load image
     }
     QApplication::restoreOverrideCursor();  // restore original cursor
 
     return success;             // TRUE if loaded OK
 }
 
 
 int ImageViewer::calcHeight()
 {
     if ( !isFullScreen )
         return  imagePanel->paneHeight();
     else
         return qApp->desktop()->height();
 }
 /*
   This functions scales the pixmap in the member variable "pm" to fit the
   widget size and  puts the resulting pixmap in the member variable "pmScaled".
 */
 void ImageViewer::scale()
 {
     int h = calcHeight();
     if ( image.isNull() ) return;
 
     QApplication::setOverrideCursor( waitCursor ); // this might take time
     if ( imagePanel->paneWidth() == pm.width() && h == pm.height() )
     { // no need to scale if widget
         pmScaled = pm;              // size equals pixmap size
     }
     else
     {
         double hs = (double)h / (double)image.height();
         double ws = (double)imagePanel->paneWidth() / (double)image.width();
         double scaleFactor = (hs > ws) ? ws : hs;
         int smoothW = (int)(scaleFactor * image.width());
         int smoothH = (int)(scaleFactor * image.height());
 
         pmScaled.convertFromImage( image.smoothScale( smoothW, smoothH ) /*, conversion_flags */ );
     }
     QApplication::restoreOverrideCursor();  // restore original cursor
 }
 
 /*
   The resize event handler, if a valid pixmap was loaded it will call
   scale() to fit the pixmap to the new widget size.
 */
 
 void ImageViewer::resizeEvent( QResizeEvent * )
 {
 
     if ( pm.size() == QSize( 0, 0 ) )       // we couldn't load the image
         return;
 
     int h = calcHeight();
 
     if ( imagePanel->paneWidth() != pmScaled.width() || h != pmScaled.height() )
     {                       // if new size,
         scale();                // scale pmScaled to window
     }
     if ( image.hasAlphaBuffer() )
         erase();
 }
 
 
 void ImageViewer::hFlip()
 {
 //    matrix.scale( -1.0, 1.0 );
 
     setImage(image.mirror(TRUE,FALSE));
 }
 
 void ImageViewer::vFlip()
 {
 //    matrix.scale( 1.0, -1.0 );
     setImage(image.mirror(FALSE,TRUE));
 }
 
 void ImageViewer::rot180()
 {
 //    matrix.rotate( 180.0 );
     setImage(image.mirror(TRUE,TRUE));
 }
 
 void ImageViewer::rot90()
 {
     QImage oldimage;
     oldimage = image.convertDepth(32);
 //    matrix.rotate( -90.0 );
     setImage(rotate(oldimage,Rotate90));
 
 }
 void ImageViewer::rot270()
 {
 
     QImage oldimage;
     oldimage = image.convertDepth(32);
 //    matrix.rotate(90.0);
     setImage(rotate(oldimage,Rotate270));
 
 }
 
 void ImageViewer::blackAndWhite()
 {
 
     viewMenuView->setItemEnabled(BLACKANDWHITE,false);
     setImage(toGray(image,false));
 }
 
 void ImageViewer::displayControlsDialog()
 {
     int w=80;
     int h=w;
     QImage small;
 
     if ( image.width()<w ||image.height()<h )
         small=image.smoothScale(w,h);
     else
         small=image.copy(0,0,w,h);
 
     int newB=0;
     ControlsDialog *dlg=new ControlsDialog("Image Viewer",small,&newB,this);
     dlg->exec();
     if ( newB ) {
         intensity(image,(float)newB/100);
         setImage(image);
     }
 
 }
 
 
 void ImageViewer::displayInfoDialog()
 {
 
     QStringList ls;
 
     for ( int i=0;i<LAST;i++ )
         ls.append(imageInfo[i]);
 
     InfoDialog::displayInfo("Image Viewer",ls,this);
 }
 void ImageViewer::normalView()
 {
     if ( !imagePanel->parentWidget() )
     {
 
         isFullScreen = FALSE;
         stack->addWidget( imagePanel, 1 );
         switchToImageView();
         if ( isSized )
             scale();
 
         updateImage();
 
     }
 }
 
 void ImageViewer::stopSlideShow() {
     if (slideTimer->isActive())
     slideTimer->stop();
 }
 
 void ImageViewer::fullScreen()
 {
     // Full-screen option
     // contributed by Robert Wittams <robert@wittams.com>
     if ( imagePanel->parentWidget() && loadSelected() )
     {
         isFullScreen = TRUE;
         imagePanel->reparent(0,QPoint(0,0));
         imagePanel->resize(qApp->desktop()->width(), qApp->desktop()->height());
 
         if ( isSized )
             scale();
         updateImage();
         imagePanel->showFullScreen();
     }
 }
 
 void ImageViewer::setImage(const QImage& newimage)
 {
     image = newimage;
     reconvertImage();
     updateImage();
 }
 
 void ImageViewer::updateImageInfo(QString &filePath)
 {
 
     for ( int i=0;i<LAST;i++ )
     {
         imageInfo[i]="";
     }
 
     imageInfo[FORMAT]=QImage::imageFormat (filePath );
     QFileInfo fi(filePath);
     imageInfo[PATH]=fi.fileName();
     imageInfo[FILE_SIZE]=QString::number(fi.size())+" (bytes)";
     QString message("%1x%2");
     imageInfo[SIZE]=QString("%1x%2");
     imageInfo[SIZE]=imageInfo[SIZE].arg(image.width()).arg(image.height());
     if ( image.numColors() > 0 )
     {
         imageInfo[COLORS]=tr("%1 colors").arg(image.numColors());
     }
     else if ( image.depth() >= 16 )
     {
         imageInfo[COLORS]=tr(" True color");
     }
     if ( image.hasAlphaBuffer() )
     {
         if ( image.depth() == 8 )
         {
             int i;
             bool alpha[256];
             int nalpha=0;
 
             for ( i=0; i<256; i++ )
                 alpha[i] = FALSE;
 
             for ( i=0; i<image.numColors(); i++ )
             {
                 int alevel = image.color(i) >> 24;
                 if ( !alpha[alevel] )
                 {
                     alpha[alevel] = TRUE;
                     nalpha++;
                 }
             }
             imageInfo[ALPHA]=tr("%1 alpha levels").arg(nalpha);
         }
         else
         {
             imageInfo[ALPHA]=tr("8-bit alpha channel");
         }
     }
 
 }
 
 void ImageViewer::closeEvent( QCloseEvent *e )
 {
     if ( stack->visibleWidget() == imagePanel && !bFromDocView )
     {
         e->ignore();
         open();
     }
     else
     {
         bFromDocView = FALSE;
         e->accept();
     }
 }
 
 // Intensity,toGray and rotate code courtesy of KDE project.
 
 
 QImage& ImageViewer::intensity(QImage &image, float percent)
 {
 
     int segColors = image.depth() > 8 ? 256 : image.numColors();
     unsigned char *segTbl = new unsigned char[segColors];
     int pixels = image.depth() > 8 ? image.width()*image.height() :
                  image.numColors();
     unsigned int *data = image.depth() > 8 ? (unsigned int *)image.bits() :
                          (unsigned int *)image.colorTable();
 
     bool brighten = (percent >= 0);
     if ( percent < 0 )
         percent = -percent;
 
     if ( brighten )
     { // keep overflow check out of loops
         for ( int i=0; i < segColors; ++i )
         {
             int tmp = (int)(i*percent);
             if ( tmp > 255 )
                 tmp = 255;
             segTbl[i] = tmp;
         }
     }
     else
     {
         for ( int i=0; i < segColors; ++i )
         {
             int tmp = (int)(i*percent);
             if ( tmp < 0 )
                 tmp = 0;
             segTbl[i] = tmp;
         }
     }
 
     if ( brighten )
     { // same here
         for ( int i=0; i < pixels; ++i )
         {
             int r = qRed(data[i]);
             int g = qGreen(data[i]);
             int b = qBlue(data[i]);
             int a = qAlpha(data[i]);
             r = r + segTbl[r] > 255 ? 255 : r + segTbl[r];
             g = g + segTbl[g] > 255 ? 255 : g + segTbl[g];
             b = b + segTbl[b] > 255 ? 255 : b + segTbl[b];
             data[i] = qRgba(r, g, b,a);
         }
     }
     else
     {
         for ( int i=0; i < pixels; ++i )
         {
             int r = qRed(data[i]);
             int g = qGreen(data[i]);
             int b = qBlue(data[i]);
             int a = qAlpha(data[i]);
             r = r - segTbl[r] < 0 ? 0 : r - segTbl[r];
             g = g - segTbl[g] < 0 ? 0 : g - segTbl[g];
             b = b - segTbl[b] < 0 ? 0 : b - segTbl[b];
             data[i] = qRgba(r, g, b, a);
         }
     }
     delete [] segTbl;
 
     return image;
 }
 
 QImage& ImageViewer::toGray(QImage &img, bool fast)
 {
     if ( img.width() == 0 || img.height() == 0 )
         return img;
 
     if ( fast )
     {
         if ( img.depth() == 32 )
         {
             register uchar * r(img.bits());
             register uchar * g(img.bits() + 1);
             register uchar * b(img.bits() + 2);
 
             uchar * end(img.bits() + img.numBytes());
 
             while ( r != end )
             {
 
                 *r = *g = *b = (((*r + *g) >> 1) + *b) >> 1; // (r + b + g) / 3
 
                 r += 4;
                 g += 4;
                 b += 4;
             }
         }
         else
         {
             for ( int i = 0; i < img.numColors(); i++ )
             {
                 register uint r = qRed(img.color(i));
                 register uint g = qGreen(img.color(i));
                 register uint b = qBlue(img.color(i));
 
                 register uint gray = (((r + g) >> 1) + b) >> 1;
                 img.setColor(i, qRgba(gray, gray, gray, qAlpha(img.color(i))));
             }
         }
     }
     else
     {
         int pixels = img.depth() > 8 ? img.width()*img.height() :
                      img.numColors();
         unsigned int *data = img.depth() > 8 ? (unsigned int *)img.bits() :
                              (unsigned int *)img.colorTable();
         int val, i;
         for ( i=0; i < pixels; ++i )
         {
             val = qGray(data[i]);
             data[i] = qRgba(val, val, val, qAlpha(data[i]));
         }
     }
     return img;
 }
 
 
 QImage  ImageViewer::rotate(QImage &img, RotateDirection r)
 {
     QImage dest;
     int x, y;
     if ( img.depth() > 8 )
     {
         unsigned int *srcData, *destData;
         switch ( r )
         {
             case Rotate90:
                 dest.create(img.height(), img.width(), img.depth());
                 for ( y=0; y < img.height(); ++y )
                 {
                     srcData = (unsigned int *)img.scanLine(y);
                     for ( x=0; x < img.width(); ++x )
                     {
                         destData = (unsigned int *)dest.scanLine(x);
                         destData[img.height()-y-1] = srcData[x];
                     }
                 }
                 break;
             case Rotate180:
                 dest.create(img.width(), img.height(), img.depth());
                 for ( y=0; y < img.height(); ++y )
                 {
                     srcData = (unsigned int *)img.scanLine(y);
                     destData = (unsigned int *)dest.scanLine(img.height()-y-1);
                     for ( x=0; x < img.width(); ++x )
                         destData[img.width()-x-1] = srcData[x];
                 }
                 break;
             case Rotate270:
                 dest.create(img.height(), img.width(), img.depth());
                 for ( y=0; y < img.height(); ++y )
                 {
                     srcData = (unsigned int *)img.scanLine(y);
                     for ( x=0; x < img.width(); ++x )
                     {
                         destData = (unsigned int *)dest.scanLine(img.width()-x-1);
                         destData[y] = srcData[x];
                     }
                 }
                 break;
             default:
                 dest = img;
                 break;
         }
     }
     else
     {
         unsigned char *srcData, *destData;
         unsigned int *srcTable, *destTable;
         switch ( r )
         {
             case Rotate90:
                 dest.create(img.height(), img.width(), img.depth());
                 dest.setNumColors(img.numColors());
                 srcTable = (unsigned int *)img.colorTable();
                 destTable = (unsigned int *)dest.colorTable();
                 for ( x=0; x < img.numColors(); ++x )
                     destTable[x] = srcTable[x];
                 for ( y=0; y < img.height(); ++y )
                 {
                     srcData = (unsigned char *)img.scanLine(y);
                     for ( x=0; x < img.width(); ++x )
                     {
                         destData = (unsigned char *)dest.scanLine(x);
                         destData[img.height()-y-1] = srcData[x];
                     }
                 }
                 break;
             case Rotate180:
                 dest.create(img.width(), img.height(), img.depth());
                 dest.setNumColors(img.numColors());
                 srcTable = (unsigned int *)img.colorTable();
                 destTable = (unsigned int *)dest.colorTable();
                 for ( x=0; x < img.numColors(); ++x )
                     destTable[x] = srcTable[x];
                 for ( y=0; y < img.height(); ++y )
                 {
                     srcData = (unsigned char *)img.scanLine(y);
                     destData = (unsigned char *)dest.scanLine(img.height()-y-1);
                     for ( x=0; x < img.width(); ++x )
                         destData[img.width()-x-1] = srcData[x];
                 }
                 break;
             case Rotate270:
                 dest.create(img.height(), img.width(), img.depth());
                 dest.setNumColors(img.numColors());
                 srcTable = (unsigned int *)img.colorTable();
                 destTable = (unsigned int *)dest.colorTable();
                 for ( x=0; x < img.numColors(); ++x )
                     destTable[x] = srcTable[x];
                 for ( y=0; y < img.height(); ++y )
                 {
                     srcData = (unsigned char *)img.scanLine(y);
                     for ( x=0; x < img.width(); ++x )
                     {
                         destData = (unsigned char *)dest.scanLine(img.width()-x-1);
                         destData[y] = srcData[x];
                     }
                 }
                 break;
             default:
                 dest = img;
                 break;
         }
 
     }
     return (dest);
 }
 
 void ImageViewer::slideShow( bool on )
 {
     if (on) {
         if (!imageList.isEmpty()) {
             slideTimer->start(slideDelay * 1000, FALSE);
             filename = "";    // force restart
             slideReverse ? prevImage() : nextImage();
         }
     } else {
         slideTimer->stop();
         slideAction->setOn( false);
     }
 }
 
 void ImageViewer::slideUpdate()
 {
     bool final_image = slideReverse ? prevImage() : nextImage();
 
     if (final_image && !slideRepeat) {
         slideTimer->stop();
         slideAction->setOn(FALSE);
     }
 }
 
 //
 // Display the image after the current one in the image list.
 // Return TRUE if the next call to nextImage() will wrap around to the
 // first image in the list (ie. we're now viewing the last image in the list).
 //
 bool ImageViewer::nextImage(void)
 {
     int idx = 0;
 
     if (imageList.count() > 0) {
         idx = imageIndex();
         if (idx != -1) {
             if (idx == int(imageList.count() - 1)) {
                 idx = 0;
             } else {
                 idx++;
             }
         } else {
             idx = 0;
         }
         openFile(imageList[idx]);
     }
 
     return idx == int(imageList.count() - 1) ? TRUE : FALSE;
 }
 
 //
 // Display the image preceeding the current one in the image list.
 // Return TRUE if the next call to prevImage() will wrap around to the last
 // image in the list (ie. we're now viewing the first image in the list).
 //
 bool ImageViewer::prevImage(void)
 {
     int idx = -1;
 
     if (imageList.count() > 0) {
         idx = imageIndex();
         if (idx != -1) {
             if (idx == 0) {
                 idx = imageList.count() - 1;
             } else {
                 idx--;
             }
         } else {
             idx = imageList.count() - 1;
         }
         openFile(imageList[idx]);
     }
 
     return idx == 0 ? TRUE : FALSE;
 }
 
 //
 // Return the index into the imageList of the currently viewed
 // image (ie. ImageViewer::filename in ImageViewer::imageList).
 //
 int ImageViewer::imageIndex(void)
 {
     QValueListConstIterator<DocLnk> i;
     int index;
 
     if (imageList.count() == 0) {
         return -1;
     }
 
     for (index = 0, i = imageList.begin(); i != imageList.end(); ++i, index++) {
         if ((*i).file() == filename) {
             return index;
         }
     }
 
     return -1;
 }
diff --git a/noncore/multimedia/tonleiter/editinst.cpp b/noncore/multimedia/tonleiter/editinst.cpp
index 5616569..ccb4560 100644
--- a/noncore/multimedia/tonleiter/editinst.cpp
+++ b/noncore/multimedia/tonleiter/editinst.cpp
@@ -1,111 +1,110 @@
 #include "editinst.h"
 
-#include <qlabel.h>
 #include <qpushbutton.h>
 
 #include <qpe/qpeapplication.h>
 
 Menu::InstEditDialog::InstEditDialog(TonleiterData* data,QWidget* parent,const char* name)
 :QDialog(parent,name,true,0),data(data)
 {
     setCaption("Tonleiter::"+tr("Instrument"));
     QBoxLayout* masterlayout=new QBoxLayout(this,QBoxLayout::TopToBottom);
     instid=data->getCurrentInstrumentID();
     stringlist.setAutoDelete(true);
 
     QBoxLayout* toplayout=new QBoxLayout(masterlayout,QBoxLayout::LeftToRight);
 
     //Name combo + Add + Delete
     boxInst=new QComboBox(this,"boxInst");
     boxInst->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     connect(boxInst,SIGNAL(activated(int)),this,SLOT(setCurrentInstrumetID(int)));
     for(int i=0;i<data->noOfInstruments();i++)
     {
         Instrument inst=data->getInstrument(i);
         QString name=inst.instName();
         if(name.isNull()) continue;
         boxInst->insertItem(name,i);
     }
     boxInst->setCurrentItem(instid);
     toplayout->addWidget(boxInst);
 
     QPushButton* addButton=new QPushButton(tr("Add"),this,"addButton");
     connect(addButton,SIGNAL(pressed()),this,SLOT(addInstrument()));
     toplayout->addWidget(addButton);
 
     QPushButton* delButton=new QPushButton(tr("Delete"),this,"delButton");
     connect(delButton,SIGNAL(pressed()),this,SLOT(deleteInstrument()));
     toplayout->addWidget(delButton);
 
     QPushButton* addhighButton=new QPushButton(tr("Add High String"),this,"addhighButton");
     masterlayout->addWidget(addhighButton);
 
     scrollview=new QScrollView(this);
     scrollview->setVScrollBarMode(QScrollView::AlwaysOn);
     scrollview->setHScrollBarMode(QScrollView::AlwaysOff);
     stringwidget=new QVBox(scrollview->viewport());
     stringwidget->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum));
     stringwidget->setSpacing(10);
     scrollview->addChild(stringwidget);
     scrollview->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     masterlayout->addWidget(scrollview);
 
     loadInstrument();
 
     QPushButton* addlowButton=new QPushButton(tr("Add Low String"),this,"addlowButton");
     masterlayout->addWidget(addlowButton);
 
     //make dialog fit the screen
     QPEApplication::showDialog( this );
 }
 //****************************************************************************
 Menu::InstEditDialog::~InstEditDialog()
 {
 }
 //****************************************************************************
 void Menu::InstEditDialog::setCurrentInstrumetID(int id)
 {
     saveInstrument();
     instid=id;
     data->setCurrentInstrumetID(id);
     loadInstrument();
 }
 //****************************************************************************
 void Menu::InstEditDialog::addInstrument()
 {
 }
 //****************************************************************************
 void Menu::InstEditDialog::deleteInstrument()
 {
 }
 //****************************************************************************
 void Menu::InstEditDialog::addLowString()
 {
 }
 //****************************************************************************
 void Menu::InstEditDialog::addHighString()
 {
 }
 //****************************************************************************
 void Menu::InstEditDialog::deleteString(int id)
 {
 }
 //****************************************************************************
 void Menu::InstEditDialog::saveInstrument()
 {
     //auto delete is set to true so widgets _should_ be deleted
     stringlist.clear();
 }
 //****************************************************************************
 void Menu::InstEditDialog::loadInstrument()
 {
     stringlist.clear();
     Instrument inst=data->getInstrument(instid);
     qDebug("load Instrument : %d strings",inst.noOfStrings());
     for(uint s=0;s<inst.noOfStrings();s++)
     {
         stringlist.append(new EditStringWidget(inst.string(s),stringwidget));
     }
 }
 //****************************************************************************
 //****************************************************************************
diff --git a/noncore/multimedia/tonleiter/editstringwidget.cpp b/noncore/multimedia/tonleiter/editstringwidget.cpp
index d22bbc5..33dc6e1 100644
--- a/noncore/multimedia/tonleiter/editstringwidget.cpp
+++ b/noncore/multimedia/tonleiter/editstringwidget.cpp
@@ -1,32 +1,31 @@
 #include "editstringwidget.h"
 
-#include <qlabel.h>
 #include <qlayout.h>
 
 using namespace Data;
 
 Menu::EditStringWidget::EditStringWidget(int note,QWidget* parent,const char* name,WFlags f)
 :QFrame(parent,name,f)
 {
     QBoxLayout* layout=new QBoxLayout(this,QBoxLayout::LeftToRight,10);
 
     boxNote=new QComboBox(this,"boxNote");
     boxNote->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     //connect(boxNote,SIGNAL(activated(int)),data,SLOT(setCurrentNote(int)));
     layout->addWidget(boxNote,1,1);
     for(int a=0;a<12;a++)
         boxNote->insertItem(Note::notenames[a],a);
     boxNote->setCurrentItem(note-12*Note::getOctaveOfNote(note));
     layout->addWidget(boxNote);
 
     setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     setFrameShape(QFrame::Panel);
     setFrameShadow(QFrame::Sunken);
 
 }
 //****************************************************************************
 Menu::EditStringWidget::~EditStringWidget()
 {
 }
 //****************************************************************************
 //****************************************************************************
diff --git a/noncore/multimedia/tonleiter/mainwidget.cpp b/noncore/multimedia/tonleiter/mainwidget.cpp
index b9c3d01..db16541 100644
--- a/noncore/multimedia/tonleiter/mainwidget.cpp
+++ b/noncore/multimedia/tonleiter/mainwidget.cpp
@@ -1,45 +1,44 @@
 #include "mainwidget.h"
 
-#include <qwidget.h>
 #include <qlayout.h>
 
 MainWidget::MainWidget(QWidget* parent,const char* name,WFlags f)
 :QMainWindow(parent,name,f)
 {
     setCaption("Tonleiter");
     data=new Data::TonleiterData(this);
 
     QWidget* mainwidget=new QWidget(this,"mainwidget");
     setCentralWidget(mainwidget);
     QBoxLayout* mainlayout=new QBoxLayout(mainwidget,QBoxLayout::TopToBottom);
 
     menuwidget=new Menu::MenuWidget(data,mainwidget);
     mainlayout->addWidget(menuwidget);
 
     fretboard=new Graph::FretBoard(data,mainwidget);
     connect(fretboard,SIGNAL(pressed()),this,SLOT(fretboardPressed()));
     mainlayout->addWidget(fretboard);
 
     showmenu=true;
 
 }
 //****************************************************************************
 MainWidget::~MainWidget()
 {
 }
 //****************************************************************************
 void MainWidget::fretboardPressed()
 {
     if(showmenu)
     {
         menuwidget->hide();
         showmenu=false;
     }
     else
     {
         menuwidget->show();
         showmenu=true;
     }
 }
 //****************************************************************************
 //****************************************************************************
diff --git a/noncore/multimedia/tonleiter/menuwidget.cpp b/noncore/multimedia/tonleiter/menuwidget.cpp
index 56a2f8a..91d052e 100644
--- a/noncore/multimedia/tonleiter/menuwidget.cpp
+++ b/noncore/multimedia/tonleiter/menuwidget.cpp
@@ -1,107 +1,105 @@
 #include "menuwidget.h"
 
-#include <qlabel.h>
-#include <qlayout.h>
 
 #include "editinst.h"
 #include "editscale.h"
 
 Menu::MenuWidget::MenuWidget(TonleiterData* data,QWidget* parent,const char* name,WFlags f)
 :QWidget(parent,name,f),data(data)
 {
     QGridLayout* layout=new QGridLayout(this,3,3,10,-1,"menulayout");
 
     //Instrument
     QLabel* instLabel=new QLabel(tr("Instr."),this,"instLabel");
     instLabel->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     layout->addWidget(instLabel,0,0);
 
     boxInst=new QComboBox(this,"boxInst");
     boxInst->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     connect(boxInst,SIGNAL(activated(int)),data,SLOT(setCurrentInstrumetID(int)));
     layout->addWidget(boxInst,0,1);
 
     editInst=new QPushButton(tr("Edit"),this,"editInst");
     editInst->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     connect(editInst,SIGNAL(pressed()),this,SLOT(editInstPressed()));
     layout->addWidget(editInst,0,2);
 
     //Note
     QLabel* noteLabel=new QLabel(tr("Note"),this,"noteLabel");
     noteLabel->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     layout->addWidget(noteLabel,1,0);
 
     boxNote=new QComboBox(this,"boxNote");
     boxNote->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     connect(boxNote,SIGNAL(activated(int)),data,SLOT(setCurrentNote(int)));
     layout->addWidget(boxNote,1,1);
     for(int a=0;a<12;a++)
         boxNote->insertItem(Note::notenames[a],a);
     boxNote->setCurrentItem(data->getCurrentBaseNote());
 
     noteCheck=new QCheckBox(tr("show"),this,"noteCheck");
     noteCheck->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     noteCheck->setChecked(data->isDrawNames());
     connect(noteCheck,SIGNAL(toggled(bool)),data,SLOT(setDrawNames(bool)));
     layout->addWidget(noteCheck,1,2);
 
     //Scale
     QLabel* scaleLabel=new QLabel(tr("Scale"),this,"scaleLabel");
     scaleLabel->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     layout->addWidget(scaleLabel,2,0);
 
     boxScale=new QComboBox(this,"boxScale");
     boxScale->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     connect(boxScale,SIGNAL(activated(int)),data,SLOT(setCurrentScaleID(int)));
     layout->addWidget(boxScale,2,1);
 
     editScale=new QPushButton(tr("Edit"),this,"editScale");
     editScale->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
     connect(editScale,SIGNAL(pressed()),this,SLOT(editScalePressed()));
     layout->addWidget(editScale,2,2);
 
     updateBoxes();
     setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Maximum));
 }
 //****************************************************************************
 Menu::MenuWidget::~MenuWidget()
 {
 }
 //****************************************************************************
 void Menu::MenuWidget::editInstPressed()
 {
     InstEditDialog* instdialog=new InstEditDialog(data,this);
     instdialog->exec();
 }
 //****************************************************************************
 void Menu::MenuWidget::editScalePressed()
 {
     ScaleEditDialog* scaledialog=new ScaleEditDialog(data,this);
     scaledialog->exec();
 }
 //****************************************************************************
 void Menu::MenuWidget::updateBoxes()
 {
     boxInst->clear();
 
     for(int i=0;i<data->noOfInstruments();i++)
     {
         Instrument inst=data->getInstrument(i);
         QString name=inst.instName();
         if(name.isNull()) continue;
         boxInst->insertItem(name,i);
     }
     boxInst->setCurrentItem(data->getCurrentInstrumentID());
 
     boxScale->clear();
     for(int s=0;s<data->noOfScales();s++)
     {
         Scale scale=data->getScale(s);
         QString name=scale.scaleName();
         if(name.isNull()) continue;
         boxScale->insertItem(name,s);
     }
     boxScale->setCurrentItem(data->getCurrentScaleID());
 }
 //****************************************************************************
 //****************************************************************************