2 files changed, 6 insertions, 7 deletions

diff --git a/libopie/odevice.cpp b/libopie/odevice.cpp
index 4c33a0e..d6e6892 100644
--- a/libopie/odevice.cpp
+++ b/libopie/odevice.cpp
@@ -682,206 +682,206 @@ void ODevice::alarmSound ( )
 
         if ( snd. isFinished ( ))
                 snd. play ( );
 #endif
 }
 
 /**
  * This plays a key sound
  */
 void ODevice::keySound ( )
 {
 #ifndef QT_NO_SOUND
         static Sound snd ( "keysound" );
 
         if ( snd. isFinished ( ))
                 snd. play ( );
 #endif
 }
 
 /**
  * This plays a touch sound
  */
 void ODevice::touchSound ( )
 {
 #ifndef QT_NO_SOUND
         static Sound snd ( "touchsound" );
 
         if ( snd. isFinished ( ))
                 snd. play ( );
 #endif
 }
 
 /**
  * This method will return a list of leds
  * available on this device
  * @return a list of LEDs.
  */
 QValueList <OLed> ODevice::ledList ( ) const
 {
         return QValueList <OLed> ( );
 }
 
 /**
  * This does return the state of the LEDs
  */
 QValueList <OLedState> ODevice::ledStateList ( OLed /*which*/ ) const
 {
         return QValueList <OLedState> ( );
 }
 
 /**
  * @return the state for a given OLed
  */
 OLedState ODevice::ledState ( OLed /*which*/ ) const
 {
         return Led_Off;
 }
 
 /**
  * Set the state for a LED
  * @param which Which OLed to use
  * @param st The state to set
  * @return success or failure
  */
 bool ODevice::setLedState ( OLed which, OLedState st )
 {
         Q_UNUSED( which )
         Q_UNUSED( st    )
         return false;
 }
 
 /**
  * @return if the device has a light sensor
  */
 bool ODevice::hasLightSensor ( ) const
 {
         return false;
 }
 
 /**
  * @return a value from the light senso
  */
 int ODevice::readLightSensor ( )
 {
         return -1;
 }
 
 /**
  * @return the light sensor resolution whatever that is ;)
  */
 int ODevice::lightSensorResolution ( ) const
 {
         return 0;
 }
 
 /**
- * @return a list with valid CPU frequency
+ * @return a list with CPU frequencies supported by the hardware
  */
-QStrList &ODevice::cpuFrequencies ( ) const
+const QStrList &ODevice::allowedCpuFrequencies ( ) const
 {
         return *d->m_cpu_frequencies;
 }
 
 
 /**
- * Set desired cpu frequency
+ * Set desired CPU frequency
  * 
  * @param index index into d->m_cpu_frequencies of the frequency to be set
  */
-bool ODevice::setCpuFrequency(uint index)
+bool ODevice::setCurrentCpuFrequency(uint index)
 {
         if (index >= d->m_cpu_frequencies->count())
                 return false;
 
         char *freq = d->m_cpu_frequencies->at(index);
         qWarning("set freq to %s", freq);
 
         int fd;
 
         if ((fd = ::open("/proc/sys/cpu/0/speed", O_WRONLY)) >= 0) {
                 char writeCommand[50];
                 const int count = sprintf(writeCommand, "%s\n", freq);
                 int res = (::write(fd, writeCommand, count) != -1);
                 ::close(fd);
                 return res;
         }
 
         return false;
 }
 
 
 /**
  * @return a list of hardware buttons
  */
 const QValueList <ODeviceButton> &ODevice::buttons ( )
 {
         initButtons ( );
 
         return *d-> m_buttons;
 }
 
 /**
  * @return The amount of time that would count as a hold
  */
 uint ODevice::buttonHoldTime ( ) const
 {
         return d-> m_holdtime;
 }
 
 /**
  * This method return a ODeviceButton for a key code
  * or 0 if no special hardware button is available for the device
  *
  * @return The devicebutton or 0l
  * @see ODeviceButton
  */
 const ODeviceButton *ODevice::buttonForKeycode ( ushort code )
 {
         initButtons ( );
 
         for ( QValueListConstIterator<ODeviceButton> it = d-> m_buttons-> begin ( ); it != d-> m_buttons-> end ( ); ++it ) {
                 if ( (*it). keycode ( ) == code )
                         return &(*it);
         }
         return 0;
 }
 
 void ODevice::reloadButtonMapping ( )
 {
         initButtons ( );
 
         Config cfg ( "ButtonSettings" );
 
         for ( uint i = 0; i < d-> m_buttons-> count ( ); i++ ) {
                 ODeviceButton &b = ( *d-> m_buttons ) [i];
                 QString group = "Button" + QString::number ( i );
 
                 QCString pch, hch;
                 QCString pm, hm;
                 QByteArray pdata, hdata;
 
                 if ( cfg. hasGroup ( group )) {
                         cfg. setGroup ( group );
                         pch = cfg. readEntry ( "PressedActionChannel" ). latin1 ( );
                         pm  = cfg. readEntry ( "PressedActionMessage" ). latin1 ( );
                         // pdata = decodeBase64 ( buttonFile. readEntry ( "PressedActionArgs" ));
 
                         hch = cfg. readEntry ( "HeldActionChannel" ). latin1 ( );
                         hm  = cfg. readEntry ( "HeldActionMessage" ). latin1 ( );
                         // hdata = decodeBase64 ( buttonFile. readEntry ( "HeldActionArgs" ));
                 }
 
                 b. setPressedAction ( OQCopMessage ( pch, pm, pdata ));
 
                 b. setHeldAction ( OQCopMessage ( hch, hm, hdata ));
         }
 }
 
 void ODevice::remapPressedAction ( int button, const OQCopMessage &action )
 {
         initButtons ( );
 
         QString mb_chan;
 
         if ( button >= (int) d-> m_buttons-> count ( ))
                 return;
diff --git a/libopie/odevice.h b/libopie/odevice.h
index 18ff5f1..f2f6467 100644
--- a/libopie/odevice.h
+++ b/libopie/odevice.h
@@ -105,145 +105,144 @@ enum OLedState {
 enum OLed {
         Led_Mail,
         Led_Power,
         Led_BlueTooth
 };
 
 enum OHardKey {
         HardKey_Datebook  = Qt::Key_F9,
         HardKey_Contacts  = Qt::Key_F10,
         HardKey_Menu      = Qt::Key_F11,
         HardKey_Home      = Qt::Key_F12,
         HardKey_Mail      = Qt::Key_F13,
         HardKey_Record    = Qt::Key_F24,
         HardKey_Suspend   = Qt::Key_F34,
         HardKey_Backlight = Qt::Key_F35,
 };
 
 enum ODirection {
         CW   = 0,
         CCW  = 1,
         Flip = 2,
 };
 
 /**
  * A singleton which gives informations about device specefic option
  * like the Hardware used, LEDs, the Base Distribution and
  * hardware key mappings.
  *
  * @short A small class for device specefic options
  * @see QObject
  * @author Robert Griebl
  * @version 1.0
  */
 class ODevice : public QObject {
         Q_OBJECT
 
 private:
         /* disable copy */
         ODevice ( const ODevice & );
 
 protected:
         ODevice ( );
         virtual void init ( );
         virtual void initButtons ( );
 
         ODeviceData *d;
 
 public:
         // sandman do we want to allow destructions? -zecke?
         virtual ~ODevice ( );
 
         static ODevice *inst ( );
 
         // information
 
         QString modelString ( ) const;
         OModel model ( ) const;
         inline OModel series ( ) const { return (OModel) ( model ( ) & Model_Series_Mask ); }
 
         QString vendorString ( ) const;
         OVendor vendor ( ) const;
 
         QString systemString ( ) const;
         OSystem system ( ) const;
 
         QString systemVersionString ( ) const;
 
         Transformation rotation ( ) const;
         ODirection direction ( ) const;
 
 // system
 
         virtual bool setSoftSuspend ( bool on );
         virtual bool suspend ( );
 
         virtual bool setDisplayStatus ( bool on );
         virtual bool setDisplayBrightness ( int brightness );
         virtual int displayBrightnessResolution ( ) const;
         virtual bool setDisplayContrast ( int contrast );
         virtual int displayContrastResolution ( ) const;
 
 // input / output
         //FIXME playAlarmSound and al might be better -zecke
         virtual void alarmSound ( );
         virtual void keySound ( );
         virtual void touchSound ( );
 
         virtual QValueList <OLed> ledList ( ) const;
         virtual QValueList <OLedState> ledStateList ( OLed led ) const;
         virtual OLedState ledState ( OLed led ) const;
         virtual bool setLedState ( OLed led, OLedState st );
 
         virtual bool hasLightSensor ( ) const;
         virtual int readLightSensor ( );
         virtual int lightSensorResolution ( ) const;
 
-        QStrList &cpuFrequencies() const;
-        bool setCpuFrequency(uint index);
-        int cpuFrequency() const;
+        const QStrList &allowedCpuFrequencies() const;
+        bool setCurrentCpuFrequency(uint index);
 
         /**
          * Returns the available buttons on this device.  The number and location
          * of buttons will vary depending on the device.  Button numbers will be assigned
          * by the device manufacturer and will be from most preferred button to least preffered
          * button.  Note that this list only contains "user mappable" buttons.
          */
         const QValueList<ODeviceButton> &buttons ( );
 
         /**
          * Returns the DeviceButton for the \a keyCode.  If \a keyCode is not found, it
          * returns 0L
          */
         const ODeviceButton *buttonForKeycode ( ushort keyCode );
 
         /**
          * Reassigns the pressed action for \a button.  To return to the factory
          * default pass an empty string as \a qcopMessage.
          */
         void remapPressedAction ( int button, const OQCopMessage &qcopMessage );
 
         /**
          * Reassigns the held action for \a button.  To return to the factory
          * default pass an empty string as \a qcopMessage.
          */
         void remapHeldAction ( int button, const OQCopMessage &qcopMessage );
 
         /**
          * How long (in ms) you have to press a button for a "hold" action
          */
         uint buttonHoldTime ( ) const;
 
 signals:
         void buttonMappingChanged ( );
 
 private slots:
         void systemMessage ( const QCString &, const QByteArray & );
 
 protected:
         void reloadButtonMapping ( );
 };
 
 }
 
 #endif