new sound config

3 files changed, 130 insertions, 61 deletions

diff --git a/core/applets/vmemo/vmemo.cpp b/core/applets/vmemo/vmemo.cpp
index c27050d..7cc4062 100644
--- a/core/applets/vmemo/vmemo.cpp
+++ b/core/applets/vmemo/vmemo.cpp
@@ -1,514 +1,512 @@
 /************************************************************************************
 **
 ** 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.
 **
 ************************************************************************************/
 // copyright 2002 Jeremy Cowgar <jc@cowgar.com>
 /*
  * $Id$
  */
 // Sun 03-17-2002  L.J.Potter <ljp@llornkcor.com>
 #include <sys/utsname.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <linux/soundcard.h>
 
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 
 typedef struct _waveheader {
   u_long  main_chunk; /* 'RIFF'  */
   u_long  length;     /* filelen */
   u_long  chunk_type; /* 'WAVE'  */
   u_long  sub_chunk;  /* 'fmt '                                               */
   u_long  sc_len;     /* length of sub_chunk, =16     
                          (chunckSize) format len */
   u_short format;     /* should be 1 for PCM-code        (formatTag)          */
 
   u_short modus;      /* 1 Mono, 2 Stereo                (channels)           */
   u_long  sample_fq;  /* samples per second              (samplesPerSecond)   */
   u_long  byte_p_sec; /* avg bytes per second            (avgBytePerSecond)   */
   u_short byte_p_spl; /* samplesize; 1 or 2 bytes        (blockAlign)         */
   u_short bit_p_spl;  /* 8, 12 or 16 bit                 (bitsPerSample)      */
 
   u_long  data_chunk; /* 'data'      */
 
   u_long  data_length;/* samplecount */
 } WaveHeader;
 
 #define RIFF        0x46464952
 #define WAVE        0x45564157
 #define FMT         0x20746D66
 #define DATA        0x61746164
 #define PCM_CODE    1
 #define WAVE_MONO   1
 #define WAVE_STEREO 2
 
 #include "vmemo.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 
 #include <qpainter.h>
 #include <qdatetime.h>
 #include <qregexp.h>
 #include <qsound.h>
 #include <qfile.h>
 #include <qmessagebox.h>
 
 int seq = 0;
 
 /* XPM */
 static char * vmemo_xpm[] = {
 "16 16 102 2",
 "   c None",
 ".  c #60636A",
 "+  c #6E6E72",
 "@  c #68696E",
 "#  c #4D525C",
 "$  c #6B6C70",
 "%  c #E3E3E8",
 "&  c #EEEEF2",
 "*  c #EAEAEF",
 "=  c #CACAD0",
 "-  c #474A51",
 ";  c #171819",
 ">  c #9B9B9F",
 ",  c #EBEBF0",
 "'  c #F4F4F7",
 ")  c #F1F1F5",
 "!  c #DEDEE4",
 "~  c #57575C",
 "{  c #010101",
 "]  c #A2A2A6",
 "^  c #747477",
 "/  c #B5B5B8",
 "(  c #AEAEB2",
 "_  c #69696D",
 ":  c #525256",
 "<  c #181C24",
 "[  c #97979B",
 "}  c #A7A7AC",
 "|  c #B0B0B4",
 "1  c #C8C8D1",
 "2  c #75757B",
 "3  c #46464A",
 "4  c #494A4F",
 "5  c #323234",
 "6  c #909095",
 "7  c #39393B",
 "8  c #757578",
 "9  c #87878E",
 "0  c #222224",
 "a  c #414144",
 "b  c #6A6A6E",
 "c  c #020C16",
 "d  c #6B6B6F",
 "e  c #68686D",
 "f  c #5B5B60",
 "g  c #8A8A8F",
 "h  c #6B6B6E",
 "i  c #ADADB2",
 "j  c #828289",
 "k  c #3E3E41",
 "l  c #CFCFD7",
 "m  c #4C4C50",
 "n  c #000000",
 "o  c #66666A",
 "p  c #505054",
 "q  c #838388",
 "r  c #A1A1A7",
 "s  c #A9A9AE",
 "t  c #A8A8B0",
 "u  c #5E5E63",
 "v  c #3A3A3E",
 "w  c #BDBDC6",
 "x  c #59595E",
 "y  c #76767C",
 "z  c #373738",
 "A  c #717174",
 "B  c #727278",
 "C  c #1C1C1E",
 "D  c #3C3C3F",
 "E  c #ADADB6",
 "F  c #54555A",
 "G  c #8B8C94",
 "H  c #5A5A5F",
 "I  c #BBBBC3",
 "J  c #C4C4CB",
 "K  c #909098",
 "L  c #737379",
 "M  c #343437",
 "N  c #8F8F98",
 "O  c #000407",
 "P  c #2D3137",
 "Q  c #B0B1BC",
 "R  c #3B3C40",
 "S  c #6E6E74",
 "T  c #95959C",
 "U  c #74747A",
 "V  c #1D1D1E",
 "W  c #91929A",
 "X  c #42444A",
 "Y  c #22282E",
 "Z  c #B0B2BC",
 "`  c #898A90",
 " . c #65656A",
 ".. c #999AA2",
 "+. c #52535A",
 "@. c #151B21",
 "#. c #515257",
 "$. c #B5B5BE",
 "%. c #616167",
 "&. c #1A1D22",
 "*. c #000713",
 "=. c #1F1F21",
 "                                ",
 "            . + @ #             ",
 "          $ % & * = -           ",
 "        ; > , ' ) ! ~           ",
 "        { ] ^ / ( _ :           ",
 "        < [ } | 1 2 3           ",
 "      4 5 6 7 8 9 0 a b c       ",
 "    d e f g h i j 3 k l m n     ",
 "      o p q r s t u v w n       ",
 "      o x y z A B C D E n       ",
 "      F G H I J K L M N O       ",
 "      P Q R S T U V W X         ",
 "        Y Z ` b  ...+.          ",
 "          @.#.$.%.&.            ",
 "            *.B =.              ",
 "      n n n n n n n n n         "};
 
 
 VMemo::VMemo( QWidget *parent, const char *_name )
     : QWidget( parent, _name )
 {
     setFixedHeight( 18 );
     setFixedWidth( 14 );
   
     recording = FALSE;
   
     struct utsname name; /* check for embedix kernel running on the zaurus*/
     if (uname(&name) != -1) {
         QString release=name.release;
         Config vmCfg("VMemo");
         vmCfg.setGroup("Defaults");
         int toggleKey = vmCfg.readNumEntry("toggleKey", -1);
   
         if(release.find("embedix",0,TRUE) !=-1)
             systemZaurus=TRUE;
         else 
             systemZaurus=FALSE;
       
         myChannel = new QCopChannel( "QPE/VMemo", this );
         connect( myChannel, SIGNAL(received(const QCString&, const QByteArray&)),
                  this, SLOT(receive(const QCString&, const QByteArray&)) );
 
         if( toggleKey != -1 ) {
             QCopEnvelope e("QPE/Desktop", "keyRegister(int key, QString channel, QString message)");
 //           e << 4096; // Key_Escape
 //          e << Key_F5; //4148
             e << toggleKey;
             e << QString("QPE/VMemo");
             e << QString("toggleRecord()");
         }
         if( vmCfg.readNumEntry("hideIcon",0) == 1)
             hide();
     }
 }
 
 VMemo::~VMemo()
 {
 }
 
 void VMemo::receive( const QCString &msg, const QByteArray &data )
 {
     QDataStream stream( data, IO_ReadOnly );
     if (msg == "toggleRecord()")  {
         if (recording) {
             fromToggle = TRUE;
             stopRecording();
         }  else {
             fromToggle = TRUE;
             startRecording();
         }
     }
 }
 
 void VMemo::paintEvent( QPaintEvent* )
 {
   QPainter p(this);
   p.drawPixmap( 0, 1,( const char** )  vmemo_xpm );
 }
 
 void VMemo::mousePressEvent( QMouseEvent * )
 {
     startRecording();
 }
 
 void VMemo::mouseReleaseEvent( QMouseEvent * )
 {
     stopRecording();
 }
 
 bool VMemo::startRecording() {
 
     if ( recording)
         return FALSE;;    
-     Config config( "Sound" );
+     Config config( "Vmemo" );
      config.setGroup( "System" );
      useAlerts = config.readBoolEntry("Alert");
 
 //      if(useAlerts) 
 //  QMessageBox::message("VMemo","Really Record?");//) ==1)
 //             return;
 //     } else {
         if (!systemZaurus )
     QSound::play(Resource::findSound("vmemob"));
 //     }
     qDebug("Start recording");
     recording = TRUE;
     if (openDSP() == -1)  {
         QMessageBox::critical(0, "VMemo", "Could not open dsp device.\n"+errorMsg, "Abort");
         recording = FALSE;
         return FALSE;
     }
   
-  Config vmCfg("VMemo");
-  vmCfg.setGroup("Defaults");
+  config.setGroup("Defaults");
   
   QDateTime dt = QDateTime::currentDateTime();
 
   QString fName;
-   Config cfg( "Sound" );
-   cfg.setGroup( "System" );
+   config.setGroup( "System" );
    fName = QPEApplication::documentDir() ;
-  fileName = cfg.readEntry("RecLocation", fName);
+  fileName = config.readEntry("RecLocation", fName);
 
   int s;
   s=fileName.find(':');
   if(s)
      fileName=fileName.right(fileName.length()-s-2);
   qDebug("filename will be "+fileName);   
    if( fileName.right(1).find('/') == -1)
            fileName+="/";
   fName = "vm_"+ dt.toString()+ ".wav";
   
   fileName+=fName;
      qDebug("filename is "+fileName);
   // No spaces in the filename
   fileName.replace(QRegExp("'"),"");
   fileName.replace(QRegExp(" "),"_");
   fileName.replace(QRegExp(":"),".");
   fileName.replace(QRegExp(","),"");
   
   if(openWAV(fileName.latin1()) == -1)  {
     QString err("Could not open the output file\n");
     err += fileName;
     QMessageBox::critical(0, "VMemo", err, "Abort");
     close(dsp);
     return FALSE;
   }
   
   QArray<int> cats(1);
-  cats[0] = vmCfg.readNumEntry("Category", 0);
+  cats[0] = config.readNumEntry("Category", 0);
   
   QString dlName("vm_");
   dlName += dt.toString();
   DocLnk l;
   l.setFile(fileName);
   l.setName(dlName);
   l.setType("audio/x-wav");
   l.setCategories(cats);
   l.writeLink();
   
   record();
   return TRUE;
 }
 
 void VMemo::stopRecording() {
   recording = FALSE;
 }
 
 int VMemo::openDSP()
 {
-    Config cfg("Sound");
+    Config cfg("Vmemo");
     cfg.setGroup("Record");
   
     speed = cfg.readNumEntry("SampleRate", 22050);
     channels = cfg.readNumEntry("Stereo", 1) ? 2 : 1; // 1 = stereo(2), 0 = mono(1)
     if (cfg.readNumEntry("SixteenBit", 1)==1)  {
         format = AFMT_S16_LE;
         resolution = 16;
     } else {
         format = AFMT_U8;
         resolution = 8;
     }
 
     qDebug("samplerate: %d, channels %d, resolution %d", speed, channels, resolution);  
 
     if(systemZaurus) {
         dsp = open("/dev/dsp1", O_RDWR); //Zaurus needs /dev/dsp1
         channels=1; //zaurus has one input channel
     }  else {
         dsp = open("/dev/dsp", O_RDWR);
     }
   
     if(dsp == -1)  {
         perror("open(\"/dev/dsp\")");
         errorMsg="open(\"/dev/dsp\")\n "+(QString)strerror(errno);
         return -1;
     }
   
     if(ioctl(dsp, SNDCTL_DSP_SETFMT , &format)==-1)  {
         perror("ioctl(\"SNDCTL_DSP_SETFMT\")");
         return -1;
     }
     if(ioctl(dsp, SNDCTL_DSP_CHANNELS , &channels)==-1)  {
         perror("ioctl(\"SNDCTL_DSP_CHANNELS\")");
         return -1;
     }
     if(ioctl(dsp, SNDCTL_DSP_SPEED , &speed)==-1)  {
         perror("ioctl(\"SNDCTL_DSP_SPEED\")");
         return -1;
     }
     if(ioctl(dsp, SOUND_PCM_READ_RATE , &rate)==-1)  {
         perror("ioctl(\"SOUND_PCM_READ_RATE\")");
         return -1;
     }
   
     return 1;
 }
 
 int VMemo::openWAV(const char *filename)
 {
   track.setName(filename);
   if(!track.open(IO_WriteOnly|IO_Truncate|IO_Raw)) {
       errorMsg=filename;
     return -1;
   }
 
   wav=track.handle();
   
   WaveHeader wh;
 
   wh.main_chunk = RIFF;
   wh.length=0; 
   wh.chunk_type = WAVE;
   wh.sub_chunk  = FMT;
   wh.sc_len     = 16;
   wh.format     = PCM_CODE;
   wh.modus      = channels;
   wh.sample_fq  = speed;
   wh.byte_p_sec = speed * channels *  resolution/8;
   wh.byte_p_spl = channels * (resolution / 8); 
   wh.bit_p_spl  = resolution;
   wh.data_chunk = DATA;
   wh.data_length= 0; 
   //    qDebug("Write header channels %d, speed %d, b/s %d, blockalign %d, bitrate %d"
   //           , wh.modus, wh.sample_fq, wh.byte_p_sec, wh.byte_p_spl, wh.bit_p_spl );
   write (wav, &wh, sizeof(WaveHeader));
   
   return 1;
 }
 
 void VMemo::record(void)
 {
     int length=0, result, value;
     qDebug("Recording");
 
     if(systemZaurus) {
         signed short sound[512], monoBuffer[512];
         if(format==AFMT_S16_LE)  {
             while(recording)   {
                 result = read(dsp, sound, 512); // 8192
                 int j=0;
                 if(systemZaurus) {
                     for (int i = 0; i < result; i++) { //since Z is mono do normally
                         monoBuffer[i] = sound[i];
                     }
                     length+=write(wav, monoBuffer, result);
                 } else { //ipaq /stereo inputs
                     for (int i = 0; i < result; i+=2) {
                         monoBuffer[j] = (sound[i]+sound[i+1])/2;
                         j++;
                     }
                     length+=write(wav, monoBuffer, result/2);
                 }
 //                  printf("%d\r",length);
 //                  fflush(stdout);
             }
         }  else { //AFMT_U8 
 // 8bit unsigned
             unsigned short sound[512], monoBuffer[512];
             while(recording)   {
                 result = read(dsp, sound, 512); // 8192
                 int j=0;
                 if(systemZaurus) {
                     for (int i = 0; i < result; i++) { //since Z is mono do normally
                         monoBuffer[i] = sound[i];
                     }
                     length+=write(wav, monoBuffer, result);
                 } else { //ipaq /stereo inputs
                     for (int i = 0; i < result; i+=2) {
                         monoBuffer[j] = (sound[i]+sound[i+1])/2;
                         j++;
                     }
                     length+=write(wav, monoBuffer, result/2);
                 }
                 length += result;
 //                  printf("%d\r",length);
 //                  fflush(stdout);
             }
 
             qApp->processEvents();
         }
 
     } else { // this is specific for ipaqs that do not have 8 bit capabilities
 
         signed short sound[512], monoBuffer[512];
 
         while(recording)  {
             result = read(dsp, sound, 512); // 8192
             write(wav, sound, result);
             length += result;
 
             qApp->processEvents();
         }
 //          printf("%d\r",length);
 //          fflush(stdout);
           //  qDebug("file has length of %d lasting %d seconds",
           //         length, (( length / speed) / channels) / 2 );
           // medialplayer states wrong length in secs
     }
 
     value = length+36;
     lseek(wav, 4, SEEK_SET);
     write(wav, &value, 4);
     lseek(wav, 40, SEEK_SET);
     write(wav, &length, 4);
     track.close();
   
     if( ioctl( dsp, SNDCTL_DSP_RESET,0) == -1)
         perror("ioctl(\"SNDCTL_DSP_RESET\")");
     ::close(dsp);
     fileName = fileName.left(fileName.length()-4);
     if(useAlerts) 
         QMessageBox::message("Vmemo"," Done recording\n"+ fileName);
     qDebug("done recording "+fileName);
     QSound::play(Resource::findSound("vmemoe"));
 }
diff --git a/core/applets/volumeapplet/volume.cpp b/core/applets/volumeapplet/volume.cpp
index e393f0f..e8921f0 100644
--- a/core/applets/volumeapplet/volume.cpp
+++ b/core/applets/volumeapplet/volume.cpp
@@ -1,380 +1,444 @@
 /**********************************************************************
 ** 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 "volume.h"
 
 #include <qpe/resource.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
 #include <qpe/qcopenvelope_qws.h>
 #endif
 
 #include <qpainter.h>
 #include <qcheckbox.h>
 #include <qslider.h>
 #include <qlayout.h>
 #include <qframe.h>
 #include <qpixmap.h>
 #include <qlabel.h>
 
 #include <qpushbutton.h>
 #include <qtimer.h>
 
 #define RATE_TIMER_INTERVAL 100
 // Ten times per second is fine (RATE_TIMER_INTERVAL 100).  A shorter time
 // results in "hanging" buttons on the iPAQ due to quite high CPU consumption.
 
 VolumeControl::VolumeControl( bool showMic, QWidget *parent, const char *name )
     : QFrame( parent, name, WDestructiveClose | WStyle_StaysOnTop | WType_Popup )
 {
   setFrameStyle( QFrame::PopupPanel | QFrame::Raised );
   createView(showMic);
 }
 
 void VolumeControl::createView(bool showMic)
 {
-    Config cfg("Sound");
-    cfg.setGroup("System");
+    Config cfg("qpe");
+    cfg.setGroup("Volume");
 //showMic = TRUE;
     QHBoxLayout *hboxLayout = new QHBoxLayout(this);
     hboxLayout->setMargin( 3 );
     hboxLayout->setSpacing( 0);
 
     QVBoxLayout *vboxButtons = new QVBoxLayout(this);
     upButton = new QPushButton( this );
     upButton->setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
     upButton->setPixmap( Resource::loadPixmap( "up" ) );
     downButton = new QPushButton( this );
     downButton->setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
     downButton->setPixmap( Resource::loadPixmap( "down" ) );
     vboxButtons->setSpacing( 2 );
+
+    upButton->setFixedHeight(26);
+    downButton->setFixedHeight(26);
     
     vboxButtons->addWidget( upButton );
     vboxButtons->addWidget( downButton );
 
     QVBoxLayout *vbox = new QVBoxLayout( this );
     QHBoxLayout *hbox = NULL;
 
     slider = new QSlider( this );
     slider->setRange( 0, 100 );
     slider->setTickmarks( QSlider::Both );
     slider->setTickInterval( 20 );
     slider->setFocusPolicy( QWidget::NoFocus );
-    slider->setValue(cfg.readNumEntry("Volume"));
+    slider->setValue(cfg.readNumEntry("VolumePercent"));
 
     QVBoxLayout *sbox = new QVBoxLayout(this);
     sbox->setMargin( 3 );
     sbox->setSpacing( 3 );
     sbox->addWidget( new QLabel("Vol", this) , 0, Qt::AlignVCenter | Qt::AlignHCenter );
     sbox->addWidget( slider, 0, Qt::AlignVCenter | Qt::AlignHCenter );
 
-    if (showMic == TRUE)  {
-        mic = new QSlider(this);
-        mic->setRange( 0, 100 );
-        mic->setTickmarks( QSlider::Both );
-        mic->setTickInterval( 20 );
-        mic->setFocusPolicy( QWidget::NoFocus );
-        mic->setValue(cfg.readNumEntry("Mic"));
+//    if (showMic == TRUE)  {
+    mic = new QSlider(this);
+    mic->setRange( 0, 100 );
+    mic->setTickmarks( QSlider::Both );
+    mic->setTickInterval( 20 );
+    mic->setFocusPolicy( QWidget::NoFocus );
+    mic->setValue(cfg.readNumEntry("Mic"));
     
-        QVBoxLayout *mbox = new QVBoxLayout(this);
-        mbox->setMargin( 3 );
-        mbox->setSpacing( 3 );
-        mbox->addWidget( new QLabel("Mic", this) , 0, Qt::AlignVCenter | Qt::AlignHCenter );
-        mbox->addWidget( mic, 0, Qt::AlignVCenter | Qt::AlignHCenter );
-
-        hbox = new QHBoxLayout( this );
-        hbox->setMargin( 3 );
-        hbox->setSpacing( 3 );
-        hbox->addLayout( sbox, 1);
-        hbox->addLayout( mbox, 1);
-    }
+    QVBoxLayout *mbox = new QVBoxLayout(this);
+    mbox->setMargin( 3 );
+    mbox->setSpacing( 3 );
+    mbox->addWidget( new QLabel("Mic", this) , 0, Qt::AlignVCenter | Qt::AlignHCenter );
+    mbox->addWidget( mic, 0, Qt::AlignVCenter | Qt::AlignHCenter );
+
+    hbox = new QHBoxLayout( this );
+    hbox->setMargin( 3 );
+    hbox->setSpacing( 3 );
+    hbox->addLayout( sbox, 1);
+    hbox->addLayout( mbox, 1);
+      //  }
   
     muteBox = new QCheckBox( tr("Mute"), this );
     muteBox->setFocusPolicy( QWidget::NoFocus );
-  
+
+    QVBoxLayout *klbox = new QVBoxLayout(this);
+
+    QLabel *Label1;
+    Label1 = new QLabel( this, "Label1" );
+    Label1->setText( tr( "Enable Sounds for:" ));
+ 
+    alarmSound = new QCheckBox( tr("Alarm Sound"), this );
+    alarmSound->setFocusPolicy( QWidget::NoFocus );
+
+    keyclicks = new QCheckBox( tr("Key Clicks"), this );
+    keyclicks->setFocusPolicy( QWidget::NoFocus );
+
+    screentaps = new QCheckBox( tr("Screen taps"), this );
+    screentaps->setFocusPolicy( QWidget::NoFocus );
+
+    
+    keyclicks->setChecked( cfg.readBoolEntry("KeySound",0));
+    screentaps->setChecked( cfg.readBoolEntry("TouchSound",0));
+    alarmSound->setChecked( cfg.readBoolEntry("AlarmSound",1));
+
+    klbox->setMargin( 3 );
+    klbox->setSpacing( 0 );
+    klbox->addWidget( Label1, 1);
+    klbox->addWidget( alarmSound, 1);
+    klbox->addWidget( keyclicks, 1);
+    klbox->addWidget( screentaps, 1);
     vbox->setMargin( 3 );
     vbox->setSpacing( 0 );
-    if (showMic == TRUE)
-        vbox->addLayout( hbox, 1 );
-    else
-        vbox->addLayout( sbox, 1);
+//    if (showMic == TRUE)
+    vbox->addLayout( hbox, 1 );
+//    else
+//        vbox->addLayout( sbox, 1);
     vbox->addWidget( muteBox, 0, Qt::AlignVCenter | Qt::AlignHCenter );
 
     hboxLayout->addLayout( vboxButtons );
-    hboxLayout->addLayout(vbox);
+    hboxLayout->addLayout( vbox);
+    hboxLayout->addLayout( klbox);
   
-    setFixedHeight( 120 );
-    setFixedWidth( sizeHint().width() );
+
+    setFixedHeight( 120);
+//     setFixedWidth( sizeHint().width() );
     setFocusPolicy(QWidget::NoFocus);
     connect( upButton, SIGNAL( pressed() ), this, SLOT( ButtonChanged() ) );
     connect( upButton, SIGNAL( released() ), this, SLOT( ButtonChanged() ) );
     connect( downButton, SIGNAL( pressed() ), this, SLOT( ButtonChanged() ) );
     connect( downButton, SIGNAL( released() ), this, SLOT( ButtonChanged() ) );
 
     rateTimer = new QTimer(this);
     connect( rateTimer,  SIGNAL( timeout() ), this, SLOT( rateTimerDone() ) );
 }
 
 void VolumeControl::keyPressEvent( QKeyEvent *e) 
 {
   switch(e->key())
   { 
   case Key_Up:
     slider->subtractStep();
     break;
   case Key_Down:
     slider->addStep();
     break;
   case Key_Space:
     muteBox->toggle();
     break;
   case Key_Escape:
     close();
     break;
   }
 }
 
 void VolumeControl::ButtonChanged()
 {
     if ( upButton->isDown() || downButton->isDown() )
     {
         rateTimerDone(); // Call it one time manually, otherwise it wont get
                          // called at all when a button is pressed for a time
                          // shorter than RATE_TIMER_INTERVAL.
         rateTimer->start( RATE_TIMER_INTERVAL, false );
     }
     else
         rateTimer->stop();
 }
 
 void VolumeControl::rateTimerDone()
 {
     if ( upButton->isDown() )
         slider->setValue( slider->value() - 2 );
     else // downButton->isDown()
         slider->setValue( slider->value() + 2 );
 }
 
 //===========================================================================
 
 VolumeApplet::VolumeApplet( QWidget *parent, const char *name )
     : QWidget( parent, name )
 {
-  Config cfg("Sound");
-  cfg.setGroup("System");
+  Config cfg("qpe");
+  cfg.setGroup("Volume");
   
   setFixedHeight( 18 );
   setFixedWidth( 14 );
   
   volumePixmap = Resource::loadPixmap( "volume" );
   
-  volumePercent = cfg.readNumEntry("Volume",50);
+  volumePercent = cfg.readNumEntry("VolumePercent",50);
   micPercent = cfg.readNumEntry("Mic", 50);
   muted = FALSE; // ### read from pref
   micMuted = FALSE; // ### read from pref
 
   advancedTimer = new QTimer(this);
   
   connect( qApp, SIGNAL( volumeChanged(bool) ), this, SLOT( volumeChanged(bool) ) );
   connect( qApp, SIGNAL( micChanged(bool) ), this, SLOT ( micChanged(bool) ) );
   connect( advancedTimer, SIGNAL( timeout() ),this, SLOT( advVolControl()) );
   
   writeSystemVolume();
   writeSystemMic();
 }
 
 VolumeApplet::~VolumeApplet()
 {
 }
 
 void VolumeApplet::keyPressEvent ( QKeyEvent * e )
 {
   QString s;
   s.setNum(e->key());
   qWarning(s);
 }
 void VolumeApplet::mousePressEvent( QMouseEvent * )
 {
   advancedTimer->start( 750, TRUE );
 }
 
 void VolumeApplet::mouseReleaseEvent( QMouseEvent * )
 {
   showVolControl(FALSE);  
 }
 
 void VolumeApplet::advVolControl()
 {
   showVolControl(TRUE);
 }
 
 void VolumeApplet::showVolControl(bool showMic)
 {
-  Config cfg("Sound");
-  cfg.setGroup("System");
-  volumePercent = cfg.readNumEntry("Volume",50);
+  Config cfg("qpe");
+  cfg.setGroup("Volume");
+  volumePercent = cfg.readNumEntry("VolumePercent",50);
   micPercent = cfg.readNumEntry("Mic", 50);
-  QString show = cfg.readEntry("ShowMic", "FALSE");
-  if(show == "TRUE") showMic = TRUE;
+  
   // Create a small volume control window to adjust the volume with
   VolumeControl *vc = new VolumeControl(showMic);
   vc->slider->setValue( 100 - volumePercent );
-  if (showMic)
-  {
+//   if (showMic)
+//   {
     vc->mic->setValue( 100 - micPercent );
     connect( vc->mic, SIGNAL( valueChanged( int ) ), this, SLOT( micMoved( int ) ) );
-  }
+//  }
 
   vc->muteBox->setChecked( muted );
   connect( vc->slider, SIGNAL( valueChanged( int ) ), this, SLOT( sliderMoved( int ) ) );
   connect( vc->muteBox, SIGNAL( toggled( bool ) ), this, SLOT( mute( bool ) ) );
+
+   Config config("qpe");
+   config.setGroup("Volume");
+
+   vc->keyclicks->setChecked( config.readBoolEntry("KeySound",0));
+   vc->screentaps->setChecked( config.readBoolEntry("TouchSound",0));
+   vc->alarmSound->setChecked( config.readBoolEntry("AlarmSound",1));
+
+  connect( vc->alarmSound, SIGNAL(toggled(bool)), this, SLOT( alarmSoundCheckToggled(bool)));
+  connect( vc->keyclicks, SIGNAL(toggled(bool)), this, SLOT( keyclicksCheckToggled(bool)));
+  connect( vc->screentaps, SIGNAL(toggled(bool)), this, SLOT( screentapsCheckToggled(bool)));
+
   QPoint curPos = mapToGlobal( rect().topLeft() );
-  vc->move( curPos.x()-(vc->sizeHint().width()-width())/2, curPos.y() - 120 );
+  vc->move( curPos.x()-(vc->sizeHint().width()/2+50), curPos.y() - 120 );
   vc->show();
 
   advancedTimer->stop();
 }
 
 void VolumeApplet::volumeChanged( bool nowMuted )
 {
     int previousVolume = volumePercent;
 
     if ( !nowMuted )
         readSystemVolume();
 
     // Handle case where muting it toggled
     if ( muted != nowMuted ) {
   muted = nowMuted;
   repaint( TRUE );
   return;
     }
 
     // Avoid over repainting
     if ( previousVolume != volumePercent )
   repaint( 2, height() - 3, width() - 4, 2, FALSE );
 }
 
 void VolumeApplet::micChanged( bool nowMuted )
 {
   if (!nowMuted)
   readSystemMic();
   micMuted = nowMuted;
 }
 
 void VolumeApplet::mute( bool toggled )
 {
     muted = toggled;
 
     // clear if removing mute
     repaint( !toggled );
     writeSystemVolume();
 }
 
 
 void VolumeApplet::sliderMoved( int percent )
 {
     setVolume( 100 - percent );
 }
 
 void VolumeApplet::micMoved( int percent )
 {
     setMic( 100 - percent );
 }
 
 void VolumeApplet::readSystemVolume()
 {
-    Config cfg("Sound");
-    cfg.setGroup("System");
-    volumePercent = cfg.readNumEntry("Volume");
+    Config cfg("qpe");
+    cfg.setGroup("Volume");
+    volumePercent = cfg.readNumEntry("VolumePercent");
 }
 
 void VolumeApplet::readSystemMic()
 {
-    Config cfg("Sound");
-    cfg.setGroup("System");
+    Config cfg("qpe");
+    cfg.setGroup("Volume");
     micPercent = cfg.readNumEntry("Mic");
 }
 
 void VolumeApplet::setVolume( int percent )
 {
     // clamp volume percent to be between 0 and 100
     volumePercent = (percent < 0) ? 0 : ((percent > 100) ? 100 : percent);
     // repaint just the little volume rectangle
     repaint( 2, height() - 3, width() - 4, 2, FALSE );
     writeSystemVolume();
 }
 
 void VolumeApplet::setMic( int percent )
 {
   // clamp volume percent to be between 0 and 100
   micPercent = (percent < 0) ? 0 : ((percent > 100) ? 100 : percent);
   writeSystemMic();
 }
 
 void VolumeApplet::writeSystemVolume()
 {
   {
-  Config cfg("Sound");
-  cfg.setGroup("System");
-  cfg.writeEntry("Volume",volumePercent);
+  Config cfg("qpe");
+  cfg.setGroup("Volume");
+  cfg.writeEntry("VolumePercent",volumePercent);
   }
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
   // Send notification that the volume has changed
   QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << muted;
 #endif
 }
 
 void VolumeApplet::writeSystemMic()
 {
   {
-  Config cfg("Sound");
-  cfg.setGroup("System");
+  Config cfg("qpe");
+  cfg.setGroup("Volume");
   cfg.writeEntry("Mic",micPercent);
   }
 #if ( defined Q_WS_QWS || defined(_WS_QWS_) ) && !defined(QT_NO_COP)
   // Send notification that the volume has changed
   QCopEnvelope( "QPE/System", "micChange(bool)" ) << micMuted;
 #endif
 }
 
 void VolumeApplet::paintEvent( QPaintEvent* )
 {
   QPainter p(this);
   
   if (volumePixmap.isNull())
   volumePixmap = Resource::loadPixmap( "volume" );
   p.drawPixmap( 0, 1, volumePixmap );
   p.setPen( darkGray );
   p.drawRect( 1, height() - 4, width() - 2, 4 );
   
   int pixelsWide = volumePercent * (width() - 4) / 100;
   p.fillRect( 2, height() - 3, pixelsWide, 2, red );
   p.fillRect( pixelsWide + 2, height() - 3, width() - 4 - pixelsWide, 2, lightGray );
   
   if ( muted ) {
   p.setPen( red );
   p.drawLine( 1, 2, width() - 2, height() - 5 );
   p.drawLine( 1, 3, width() - 2, height() - 4 );
   p.drawLine( width() - 2, 2, 1, height() - 5 );
   p.drawLine( width() - 2, 3, 1, height() - 4 );
   }
 }
+
+void VolumeApplet::screentapsCheckToggled(bool b) {
+  Config cfg("qpe");
+  cfg.setGroup("Volume");
+  cfg.writeEntry("TouchSound",b );
+  cfg.write();
+}
+
+void VolumeApplet::keyclicksCheckToggled(bool b) {
+  Config cfg("qpe");
+  cfg.setGroup("Volume");
+  cfg.writeEntry("KeySound",b);
+  cfg.write();
+}
+
+void VolumeApplet::alarmSoundCheckToggled(bool b) {
+  Config cfg("qpe");
+  cfg.setGroup("Volume");
+  cfg.writeEntry("AlarmSound",b);
+  cfg.write();
+}
+
diff --git a/core/applets/volumeapplet/volume.h b/core/applets/volumeapplet/volume.h
index 3a2da43..6e631f2 100644
--- a/core/applets/volumeapplet/volume.h
+++ b/core/applets/volumeapplet/volume.h
@@ -1,101 +1,108 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #ifndef __VOLUME_APPLET_H__
 #define __VOLUME_APPLET_H__
 
 
 #include <qwidget.h>
-#include <qpushbutton.h>
 #include <qframe.h>
 #include <qpixmap.h>
 #include <qguardedptr.h>
 #include <qtimer.h>
 
 class QSlider;
 class QCheckBox;
 
 class VolumeControl : public QFrame
 {
     Q_OBJECT
 public:
     VolumeControl( bool showMic=FALSE, QWidget *parent=0, const char *name=0 );
 
 public:
     QSlider *slider;
     QSlider *mic;
     QCheckBox *muteBox;
+    QCheckBox *alarmSound;
+    QCheckBox *screentaps;
+    QCheckBox *keyclicks;
+
 
 private:
     QPushButton *upButton;
     QPushButton *downButton;
     QTimer *rateTimer;
     
     void keyPressEvent( QKeyEvent * );
     void createView(bool showMic = FALSE);
 private slots:
     void ButtonChanged();
     void rateTimerDone();
     
 };
 
 class VolumeApplet : public QWidget
 {
     Q_OBJECT
 public:
     VolumeApplet( QWidget *parent = 0, const char *name=0 );
     ~VolumeApplet();
     bool isMute( ) { return muted; }
     int percent( ) { return volumePercent; }
 
 public slots:
     void volumeChanged( bool muted );
     void micChanged( bool muted );
     void sliderMoved( int percent );
     void mute( bool );
 
     void micMoved( int percent );
     void setVolume( int percent );
     void setMic( int percent );
 
     void showVolControl(bool showMic = FALSE);
     void advVolControl();
 
 private:
     int volumePercent, micPercent;
     bool muted, micMuted;
     QPixmap volumePixmap;
     QTimer *advancedTimer;
 
     void readSystemVolume();
     void writeSystemVolume();
     void mousePressEvent( QMouseEvent * );
     void paintEvent( QPaintEvent* );
 
     void readSystemMic();
     void keyPressEvent ( QKeyEvent * e );
     void mouseReleaseEvent( QMouseEvent *);
     void writeSystemMic();
 
+protected slots:
+    void alarmSoundCheckToggled(bool);
+    void keyclicksCheckToggled(bool);
+    void screentapsCheckToggled(bool); 
 };
 
 
 #endif // __VOLUME_APPLET_H__