slightly more correct way to calculate the brightness

1 files changed, 1 insertions, 1 deletions

diff --git a/libopie2/opiecore/device/odevice_zaurus.cpp b/libopie2/opiecore/device/odevice_zaurus.cpp
index e75e777..fb23e1d 100644
--- a/libopie2/opiecore/device/odevice_zaurus.cpp
+++ b/libopie2/opiecore/device/odevice_zaurus.cpp
@@ -229,362 +229,362 @@ void Zaurus::initButtons()
 
         b. setKeycode ( zb->code );
         b. setUserText ( QObject::tr ( "Button", zb->utext ));
         b. setPixmap ( Resource::loadPixmap ( zb->pix ));
         b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( zb->fpressedservice ),
                                 zb->fpressedaction ));
         b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( zb->fheldservice ),
                                 zb->fheldaction ));
 
         d->m_buttons->append ( b );
     }
 
     reloadButtonMapping();
 }
 
 
 
 typedef struct sharp_led_status {
     int which;   /* select which LED status is wanted. */
     int status;  /* set new led status if you call SHARP_LED_SETSTATUS */
 } sharp_led_status;
 
 void Zaurus::buzzer( int sound )
 {
 #ifndef QT_NO_SOUND
     Sound *snd = 0;
 
     // Not all devices have real sound
     if ( d->m_model == Model_Zaurus_SLC7x0
       || d->m_model == Model_Zaurus_SLB600 
       || d->m_model == Model_Zaurus_SL6000 ) {
 
         switch ( sound ){
         case SHARP_BUZ_TOUCHSOUND: {
             static Sound touch_sound("touchsound");
             snd = &touch_sound;
         }
             break;
         case SHARP_BUZ_KEYSOUND: {
             static Sound key_sound( "keysound" );
             snd = &key_sound;
         }
             break;
         case SHARP_BUZ_SCHEDULE_ALARM:
         default: {
             static Sound alarm_sound("alarm");
             snd = &alarm_sound;
                 }    
             break;
         }
     }
 
     // If a soundname is defined, we expect that this device has
     // sound capabilities.. Otherwise we expect to have the buzzer
     // device..
     if ( snd && snd->isFinished() ){
         changeMixerForAlarm( 0, "/dev/sound/mixer", snd );
         snd->play();
     } else if( !snd ) {
         int fd = ::open ( "/dev/sharp_buz", O_WRONLY|O_NONBLOCK );
 
         if ( fd >= 0 ) {
             ::ioctl ( fd, SHARP_BUZZER_MAKESOUND, sound );
             ::close ( fd );
         }
 
     }
 #endif
 }
 
 
 void Zaurus::playAlarmSound()
 {
     buzzer( SHARP_BUZ_SCHEDULE_ALARM );
 }
 
 void Zaurus::playTouchSound()
 {
     buzzer( SHARP_BUZ_TOUCHSOUND );
 }
 
 void Zaurus::playKeySound()
 {
     buzzer( SHARP_BUZ_KEYSOUND );
 }
 
 
 QValueList <OLed> Zaurus::ledList() const
 {
     QValueList <OLed> vl;
     vl << Led_Mail;
     return vl;
 }
 
 QValueList <OLedState> Zaurus::ledStateList ( OLed l ) const
 {
     QValueList <OLedState> vl;
 
     if ( l == Led_Mail )
         vl << Led_Off << Led_On << Led_BlinkSlow;
     return vl;
 }
 
 OLedState Zaurus::ledState ( OLed which ) const
 {
     if ( which == Led_Mail )
         return m_leds [0];
     else
         return Led_Off;
 }
 
 bool Zaurus::setLedState ( OLed which, OLedState st )
 {
     if (!m_embedix) // Currently not supported on non_embedix kernels
         return false;
 
     static int fd = ::open ( "/dev/sharp_led", O_RDWR|O_NONBLOCK );
 
     if ( which == Led_Mail ) {
         if ( fd >= 0 ) {
             struct sharp_led_status leds;
             ::memset ( &leds, 0, sizeof( leds ));
             leds. which = SHARP_LED_MAIL_EXISTS;
             bool ok = true;
 
             switch ( st ) {
                 case Led_Off      : leds. status = LED_MAIL_NO_UNREAD_MAIL; break;
                 case Led_On       : leds. status = LED_MAIL_NEWMAIL_EXISTS; break;
                 case Led_BlinkSlow: leds. status = LED_MAIL_UNREAD_MAIL_EX; break;
                 default            : ok = false;
             }
 
             if ( ok && ( ::ioctl ( fd, SHARP_LED_SETSTATUS, &leds ) >= 0 )) {
                 m_leds [0] = st;
                 return true;
             }
         }
     }
     return false;
 }
 
 bool Zaurus::setSoftSuspend ( bool soft )
 {
     if (!m_embedix) {
         /* non-Embedix kernels dont have kernel autosuspend */
         return ODevice::setSoftSuspend( soft );
     }
 
     bool res = false;
     int fd;
 
     if ((( fd = ::open ( "/dev/apm_bios", O_RDWR )) >= 0 ) ||
         (( fd = ::open ( "/dev/misc/apm_bios",O_RDWR )) >= 0 )) {
 
         int sources = ::ioctl ( fd, APM_IOCGEVTSRC, 0 ); // get current event sources
 
         if ( sources >= 0 ) {
             if ( soft )
                 sources &= ~APM_EVT_POWER_BUTTON;
             else
                 sources |= APM_EVT_POWER_BUTTON;
 
             if ( ::ioctl ( fd, APM_IOCSEVTSRC, sources ) >= 0 ) // set new event sources
                 res = true;
             else
                 perror ( "APM_IOCGEVTSRC" );
         }
         else
             perror ( "APM_IOCGEVTSRC" );
 
         ::close ( fd );
     }
     else
         perror ( "/dev/apm_bios or /dev/misc/apm_bios" );
 
     return res;
 }
 
 bool Zaurus::setDisplayBrightness( int bright )
 {
     //qDebug( "Zaurus::setDisplayBrightness( %d )", bright );
     bool res = false;
 
     if ( bright > 255 ) bright = 255;
     if ( bright < 0 ) bright = 0;
 
     if ( m_embedix )
     {
         int numberOfSteps = displayBrightnessResolution();
         int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );       
         if ( fd )
         {
-            int val = ( numberOfSteps * 255 ) / 255;
+            int val = ( bright * numberOfSteps ) / 255;
             res = ( ::ioctl ( fd, SHARP_FL_IOCTL_STEP_CONTRAST, val ) == 0 );
             ::close ( fd );
         }
     }
     else
     {
         qDebug( "ODevice handling for non-embedix kernels not yet implemented" );
     }
     return res;
 }
 
 bool Zaurus::setDisplayStatus( bool on )
 {
     bool res = false;
     if ( m_embedix )
     {
         int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );       
         if ( fd )
         {
             int ioctlnum = on ? SHARP_FL_IOCTL_ON : SHARP_FL_IOCTL_OFF;
             res = ( ::ioctl ( fd, ioctlnum, 0 ) == 0 );
             ::close ( fd );
         }
     }
     else
     {
         qDebug( "ODevice handling for non-embedix kernels not yet implemented" );
     }
     return res;
 }    
 
 bool Zaurus::suspend()
 {
     qDebug("ODevice::suspend");
     if ( !isQWS( ) ) // only qwsserver is allowed to suspend
         return false;
 
     if ( d->m_model == Model_Unknown ) // better don't suspend in qvfb / on unkown devices
         return false;
 
     bool res = false;
     ODevice::sendSuspendmsg();
 
     struct timeval tvs, tvn;
     ::gettimeofday ( &tvs, 0 );
 
     ::sync(); // flush fs caches
     res = ( ::system ( "apm --suspend" ) == 0 );
 
     // This is needed because the apm implementation is asynchronous and we
     // can not be sure when exactly the device is really suspended
     if ( res ) {
         do { // Yes, wait 15 seconds. This APM sucks big time.
             ::usleep ( 200 * 1000 );
             ::gettimeofday ( &tvn, 0 );
         } while ((( tvn. tv_sec - tvs. tv_sec ) * 1000 + ( tvn. tv_usec - tvs. tv_usec ) / 1000 ) < 15000 );
     }
 
     QCopEnvelope ( "QPE/Rotation", "rotateDefault()" );
     return res;
 }
 
 
 Transformation Zaurus::rotation() const
 {
     Transformation rot;
     int handle = 0;
     int retval = 0;
 
     switch ( d->m_model ) {
         case Model_Zaurus_SLC7x0:
             handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
             if (handle == -1) {
                 return Rot270;
             } else {
                 retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
                 ::close (handle);
 
                 if (retval == 2 )
                     rot = Rot0;
                 else
                     rot = Rot270;
             }
             break;
         case Model_Zaurus_SLA300:
         case Model_Zaurus_SLB600:
         case Model_Zaurus_SL5500:
         case Model_Zaurus_SL5000:
         default:
             rot = d->m_rotation;
             break;
     }
 
     return rot;
 }
 ODirection Zaurus::direction() const
 {
     ODirection dir;
     int handle = 0;
     int retval = 0;
     switch ( d->m_model ) {
         case Model_Zaurus_SLC7x0:
             handle = ::open( "/dev/apm_bios", O_RDWR|O_NONBLOCK );
             if (handle == -1) {
                 dir = CW;
             } else {
                 retval = ::ioctl( handle, SHARP_IOCTL_GET_ROTATION );
                 ::close (handle);
                 if (retval == 2 )
                     dir = CCW;
                 else
                     dir = CW;
             }
             break;
         case Model_Zaurus_SLA300:
         case Model_Zaurus_SLB600:
         case Model_Zaurus_SL5500:
         case Model_Zaurus_SL5000:
         default: dir = d->m_direction; 
             break;
     }
     return dir;
 
 }
 
 int Zaurus::displayBrightnessResolution() const
 {
     if (m_embedix)
     {
         int handle = ::open( SHARP_FL_IOCTL_DEVICE, O_RDWR|O_NONBLOCK );
         if ( handle != -1 ) return ::ioctl( handle, SHARP_FL_IOCTL_GET_STEP, 0 );
         else return 1;
     }
     else
     {
         qDebug( "ODevice handling for non-embedix kernels not yet implemented" );
         return 1;
     }
 }
 
 bool Zaurus::hasHingeSensor() const
 {
     return d->m_model == Model_Zaurus_SLC7x0;
 }
 
 OHingeStatus Zaurus::readHingeSensor()
 {
     int handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
     if (handle == -1)
     {
         qWarning("Zaurus::readHingeSensor() - failed (%s)", "unknown reason" ); //FIXME: use strerror
         return CASE_UNKNOWN;
     }
     else
     {
         int retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
         ::close (handle);
         if ( retval == CASE_CLOSED || retval == CASE_PORTRAIT || retval == CASE_LANDSCAPE )
         {
             qDebug( "Zaurus::readHingeSensor() - result = %d", retval );
             return static_cast<OHingeStatus>( retval );
         }
         else
         {
             qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" );
             return CASE_UNKNOWN;
         }
     }
 }