X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fmainwindow.cpp;h=8cfd5ee1a1199e4eddeae0884b025095d276c08c;hb=ce8836f797ca80b4b0bdf188ec00bd5bcfb55145;hp=ae3ae67f48b9cbde1584336f961332db196b9bad;hpb=31b8d1a1c494219efd0b18f7c0bee5fb6d80e187;p=qcpufreq diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp old mode 100755 new mode 100644 index ae3ae67..8cfd5ee --- a/src/mainwindow.cpp +++ b/src/mainwindow.cpp @@ -1,6 +1,6 @@ /* * QCPUFreq - a simple cpufreq GUI - * Copyright (C) 2010 Daniel Klaffenbach + * Copyright (C) 2010 Daniel Klaffenbach * * 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 @@ -27,44 +27,53 @@ #include #endif - #define APPNAME "QCPUFreq" -#define APPVERSION "0.3" +#define APPVERSION "0.4.2" + MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), - ui(new Ui::MainWindow) + ui(new Ui::MainWindow), + //create helper process + helperProcess( this ), + //create a new, stackable help window + helpWindow( this ), + //create UI refresh timer + refreshTimer( this ), + //create a QGraphicsScene for the little chip icon + scene( this ) { //this is a stacked window on Maemo 5 #if defined(Q_WS_MAEMO_5) - setAttribute(Qt::WA_Maemo5StackedWindow); + setAttribute(Qt::WA_Maemo5StackedWindow); #endif ui->setupUi(this); - refresh(); + //Settings widget + settings = new Settings; + settings->hide(); - // enable auto rotation - setAutoRotation(); + //load preset dialog + loadPresetDialog = new LoadPreset; + loadPresetDialog->hide(); - //create a QGraphicsScene for the little chip icon - scene = new QGraphicsScene(); + init(); + + //applies the settings from the settings dialog + applySettings(); + + //initialize orientation orientationChanged(); - //create the refresh timer - refreshTimer = new QTimer(); //refresh UI every 10 seconds - refreshTimer->start( 10000 ); - - //create helper process - helperProcess = new QProcess; + refreshTimer.start( 10000 ); - //create a new, stackable help window - helpWindow = new HelpWindow( this ); + // initialize stackable help window #if defined(Q_WS_MAEMO_5) - helpWindow->setAttribute(Qt::WA_Maemo5StackedWindow); + helpWindow.setAttribute(Qt::WA_Maemo5StackedWindow); #endif - helpWindow->setWindowFlags( windowFlags() | Qt::Window ); + helpWindow.setWindowFlags( windowFlags() | Qt::Window ); //show errors about the sudo setup only once showSudoError = true; @@ -75,15 +84,19 @@ MainWindow::MainWindow(QWidget *parent) : connect( ui->freq_adjust, SIGNAL(valueChanged(int)), this, SLOT(adjustFreq()) ); connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(orientationChanged())); connect(ui->sr_box, SIGNAL(clicked()), this, SLOT(setSmartReflex())); - connect(refreshTimer, SIGNAL(timeout()), this, SLOT(refresh())); + connect(&refreshTimer, SIGNAL(timeout()), this, SLOT(refresh())); + connect(ui->actionSave, SIGNAL(triggered()), this, SLOT(save())); + connect(ui->actionLoad, SIGNAL(triggered()), loadPresetDialog, SLOT(show())); + connect(ui->actionSettings, SIGNAL(triggered()), this, SLOT(showSettings())); + connect(settings, SIGNAL(settingsChanged()), this, SLOT(applySettings())); + connect(loadPresetDialog, SIGNAL(load(QString)), this, SLOT(loadPreset(QString))); } MainWindow::~MainWindow() { - delete helpWindow; - delete refreshTimer; - delete scene; + delete loadPresetDialog; + delete settings; delete ui; } @@ -104,11 +117,74 @@ void MainWindow::about() void MainWindow::adjustFreq() { int newmax = getScalingFreq( ui->freq_adjust->sliderPosition() ); + + if (newmax == getMaxFreq() ) { + //we do not need to change anything in this case + return; + } + QString max; + + //maxfreq should not be smaller than minfreq, because we do not want to decrease minfreq + if (newmax < getMinFreq()) + newmax = getMinFreq(); + max.setNum( newmax ); + //check for overclocking + #if defined(Q_WS_MAEMO_5) + if (!settings->useOverclocking() && newmax > 600000) { + QMaemo5InformationBox::information(this, tr( "You need to enable overclocking in QCPUFreq's settings in order to set frequencies above 600MHz!"), 0); + refresh(); + return; + } + #endif + + //check for 599MHz <-> 600MHz problem on power kernels + if (max == "600000" && settings->usePowerKernel()) { + //we really need to set the maximum to 599MHz + max = "599000"; + } + + if (settings->useConfirmation()) { + QMessageBox box; + box.setStandardButtons(QMessageBox::Apply | QMessageBox::Cancel); + box.setDefaultButton(QMessageBox::Apply); + box.setIcon(QMessageBox::Question); + box.setText(tr("You have requested to change the maximum frequency.")); + QString verboseMax; + verboseMax.setNum( newmax/1000 ); + box.setInformativeText( tr("Do you really want to use %1 MHz as the new maximum frequency?").arg(verboseMax) ); + int ret = box.exec(); + + if (ret != QMessageBox::Apply) { + refresh(); + return; + } + } + callHelper( "set_maxfreq", max ); + refresh(); + +} + + +/** + * SLOT: applies the settings from the Settings dialog. + */ +void MainWindow::applySettings() +{ + setAutoRotation(); + setAdvancedTemperature(); + + //if overclocking is/was enabled we can also enable the "Load preset" option + if (settings->useOverclocking() && settings->usePowerKernel() && settings->isKernelConfigInstalled()) { + ui->actionLoad->setEnabled(true); + } else { + ui->actionLoad->setEnabled(false); + } + //refresh the GUI after applying the settings refresh(); } @@ -125,24 +201,24 @@ int MainWindow::callHelper(QString action, QString param) QStringList arguments; #if defined(Q_WS_MAEMO_5) - //On Maemo 5 the helper script resides in /opt/usr/bin, which us usually not in $PATH - arguments.append( "/opt/usr/bin/QCPUFreq.helper" ); + //On Maemo 5 the helper script resides in /opt/usr/bin, which is usually not in $PATH + arguments.append( "/opt/usr/bin/QCPUFreq.helper" ); #else - arguments.append( "QCPUFreq.helper" ); + arguments.append( "QCPUFreq.helper" ); #endif arguments.append( action ); arguments.append( param ); - helperProcess->start( "sudo", arguments, QIODevice::NotOpen ); + helperProcess.start( "sudo", arguments, QIODevice::NotOpen ); - if ( showSudoError && !helperProcess->waitForFinished( 400 )) { - //do not show this error again - showSudoError = false; - QMessageBox::critical(this, tr("QCPUFreq"), tr("There seems to be a problem with your sudo setup!")); + if ( showSudoError && !helperProcess.waitForFinished( 2000 )) { + //do not show this error again + showSudoError = false; + QMessageBox::critical(this, tr("QCPUFreq"), tr("There seems to be a problem with your sudo setup!")); } - return helperProcess->exitCode(); + return helperProcess.exitCode(); } @@ -156,18 +232,24 @@ QString MainWindow::getCPUTemp() //check if we can read a more accurate temperature (only for power kernel) if (file.exists()) - return QString( readSysFile( "class/power_supply/bq27200-0/temp" ) + " " + QString::fromUtf8("\302\260") + "C" ); + return QString( readSysFile( "class/power_supply/bq27200-0/temp" ) + " " + QString::fromUtf8("\302\260") + "C" ); else { - //read the current system temperature - QString tstring = readSysFile( "devices/platform/omap34xx_temp/temp1_input_raw" ); - if (tstring == "0") - return tr( "Unknown" ); - - //convert it to an integer and calculate the approx. temperature from the raw value - int tint = tstring.toInt(); - tint = ( 0.65 * tint ); - tstring.setNum(tint); - return QString( tstring + " " + QString::fromUtf8("\302\260") + "C" ); + /* + We actually only need to read the raw temperature, but it appears that by also reading temp1_input + the raw temperature (temp1_input_raw) is being updated more frequently. + */ + readSysFile( "devices/platform/omap34xx_temp/temp1_input" ); + + //read the current system temperature + QString tstring = readSysFile( "devices/platform/omap34xx_temp/temp1_input_raw" ); + if (tstring == "0") + return tr( "Unknown" ); + + //convert it to an integer and calculate the approx. temperature from the raw value + int tint = tstring.toInt(); + tint = ( 0.65 * tint ); + tstring.setNum(tint); + return QString( tstring + " " + QString::fromUtf8("\302\260") + "C" ); } #endif return tr( "Unknown" ); @@ -189,8 +271,7 @@ int MainWindow::getMaxFreq() */ int MainWindow::getMinFreq() { - QString tmp = readSysFile( "devices/system/cpu/cpu0/cpufreq/scaling_min_freq" ); - return tmp.toInt(); + return this->minFreq; } @@ -199,23 +280,20 @@ int MainWindow::getMinFreq() */ int MainWindow::getScalingFreq(int step) { - QString tmp = readSysFile( "devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies" ); - QStringList freqs = tmp.split( " " ); step = step - 1; if ( step < 0 ) step = 0; - if ( step > getScalingSteps() ) - step = getScalingSteps(); + if ( step > getScalingSteps() - 1 ) + step = getScalingSteps() - 1; - tmp = freqs[ step ]; - return tmp.toInt(); + return this->scalingFrequencies[ step ].toInt(); } /** * Returns the name of the current CPU frequency scaling governor * - * \return name of governor + * @return QString - name of governor */ QString MainWindow::getScalingGovernor() { @@ -225,26 +303,25 @@ QString MainWindow::getScalingGovernor() /** * Returns the amount of available scaling steps. + * + * @return int */ int MainWindow::getScalingSteps() { - QString tmp = readSysFile( "devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies" ); - QStringList freqs = tmp.split( " " ); - return (freqs.size() - 1); + return this->scalingSteps; } /** * Returns the scaling step for the specified frequency. + * + * @return int */ int MainWindow::getScalingStep( int freq ) { - for( int i = 1; i <= getScalingSteps(); ++i ) { - if ( getScalingFreq(i) == freq ) - return i; - } - - return 1; + QString tmp; + tmp.setNum(freq); + return this->scalingFrequencies.indexOf(tmp) + 1; } @@ -259,10 +336,11 @@ int MainWindow::getSmartReflexState() #if defined(Q_WS_MAEMO_5) QString tmp = readSysFile( "power/sr_vdd1_autocomp" ); - if ( tmp == "1" ) - return 1; - else - return 0; + if ( tmp == "1" ) { + return 1; + } else { + return 0; + } #else //disable UI checkbox ui->sr_box->setDisabled( true ); @@ -273,6 +351,76 @@ int MainWindow::getSmartReflexState() /** + * Initializes internal variables, such as: + * - scalingSteps + * - scalingFrequencies + * - minFreq + */ +void MainWindow::init() +{ + this->minFreq = 0; + QString freqs = readSysFile( "devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies" ); + QStringList freqList = freqs.split( " " ); + //change the order of the QStringList - last element becomes first + for (int i=freqList.size() - 1; i>=0; --i) { + if (freqList.at(i) != "") + this->scalingFrequencies << freqList.at(i); + } + this->scalingSteps = (this->scalingFrequencies.size()); + + //set minFreq and check avoid_frequencies + QString min = readSysFile( "devices/system/cpu/cpu0/cpufreq/scaling_min_freq" ); + //check if avoid file exists (only on power kernel) + QFile file( "/sys/devices/system/cpu/cpu0/cpufreq/ondemand/avoid_frequencies" ); + if (file.exists()) { + QString avoid = readSysFile( "devices/system/cpu/cpu0/cpufreq/ondemand/avoid_frequencies" ); + QStringList avoidList = avoid.split( " " ); + + //check if min is in avoid_frequencies + for (int i = getScalingStep( min.toInt() ); i <= this->scalingSteps; ++i) { + min.setNum( getScalingFreq(i) ); + if (!avoidList.contains(min)) { + this->minFreq = min.toInt(); + break; + } + } + } else { + this->minFreq = min.toInt(); + } + file.close(); + + //enable save and load option on power kernels + if (settings->usePowerKernel() && settings->isKernelConfigInstalled()) { + ui->actionSave->setEnabled(true); + //loading presets may cause overclocking - only enable it if overclokcing is enabled + if (settings->useOverclocking()) { + ui->actionLoad->setEnabled(true); + } + } +} + + +/** + * Loads a voltage preset by calling kernel-config. + * + * Available presets are: + * - default + * - ideal + * - lv + * - ulv + * - xlv + * - custom -> any preset named "custom" + */ +void MainWindow::loadPreset(QString presetName) +{ + #if defined(Q_WS_MAEMO_5) + callHelper("loadpreset", presetName); + QMaemo5InformationBox::information(this, tr( "The preset was loaded." ), QMaemo5InformationBox::DefaultTimeout); + #endif +} + + +/** * Reads any file in /sys/ * * \param sys_file : full path to sys file - omit "/sys/" @@ -284,8 +432,8 @@ QString MainWindow::readSysFile(QString sys_file) //open the file if ( !file.exists() || !file.open( QIODevice::ReadOnly ) ) { - QMessageBox::critical(this, tr("QCPUFreq"), tr("Could not get information from /sys!")); - return ""; + QMessageBox::critical(this, tr("QCPUFreq"), tr("Could not get information from /sys!")); + return ""; } //read the file @@ -325,18 +473,15 @@ void MainWindow::refresh() //smart reflex button if ( getSmartReflexState() == 1 ) - ui->sr_box->setCheckState( Qt::Checked ); + ui->sr_box->setCheckState( Qt::Checked ); else - ui->sr_box->setCheckState( Qt::Unchecked ); + ui->sr_box->setCheckState( Qt::Unchecked ); //display frequency slider ui->freq_adjust->setMinimum( 1 ); ui->freq_adjust->setMaximum( getScalingSteps() ); - ui->freq_adjust->setInvertedAppearance( true ); ui->freq_adjust->setSliderPosition( getScalingStep(getMaxFreq()) ); - - //ui->retranslateUi(this); } @@ -349,33 +494,60 @@ void MainWindow::orientationChanged() //check whether we are using portrait or landscape mode if ( usePortrait() ) { - //in portrait mode we want to display the large image - image.load( ":/img/chip256" ); - this->scene->clear(); - this->scene->addPixmap( image ); - - ui->graphicsPortrait->setScene( this->scene ); - ui->graphicsPortrait->setMaximumSize( 256, 256 ); - ui->graphicsLandscape->setMaximumSize( 0, 0 ); + //in portrait mode we want to display the large image + image.load( ":/img/chip256" ); + scene.clear(); + scene.addPixmap( image ); + + ui->graphicsPortrait->setScene( &scene ); + ui->graphicsPortrait->setMaximumSize( 256, 256 ); + ui->graphicsLandscape->setMaximumSize( 0, 0 ); } else { - image.load( ":/img/chip128" ); - this->scene->clear(); - this->scene->addPixmap( image ); + image.load( ":/img/chip128" ); + scene.clear(); + scene.addPixmap( image ); + + ui->graphicsLandscape->setScene( &scene ); + ui->graphicsLandscape->setMaximumSize( 128, 128 ); + ui->graphicsPortrait->setMaximumSize( 0, 0 ); + } +} + + +/** + * Saves the current maximim frequency as default (only on power kernel). + */ +void MainWindow::save() +{ + if (settings->usePowerKernel()) { + callHelper( "save", "null" ); + #if defined(Q_WS_MAEMO_5) + QMaemo5InformationBox::information(this, tr( "The current frequency settings have been saved as default." ), QMaemo5InformationBox::DefaultTimeout); + #endif + } +} + - ui->graphicsLandscape->setScene( this->scene ); - ui->graphicsLandscape->setMaximumSize( 128, 128 ); - ui->graphicsPortrait->setMaximumSize( 0, 0 ); +/** + * Checks the settings if the "bq27x00_battery" needs to be loaded. + */ +void MainWindow::setAdvancedTemperature() +{ + if (settings->usePowerKernel() && settings->useAdvancedTemperature()) { + callHelper( "load_bq27", "null" ); } } /** - * Enables the auto-rotation feature of Maemo5 devices + * Enables or disables the auto-rotation feature of Maemo5 devices. */ void MainWindow::setAutoRotation() { #if defined(Q_WS_MAEMO_5) - setAttribute(Qt::WA_Maemo5AutoOrientation, true); + setAttribute(Qt::WA_Maemo5AutoOrientation, settings->useAutoRotate()); + loadPresetDialog->setAttribute(Qt::WA_Maemo5AutoOrientation, settings->useAutoRotate()); + settings->setAttribute(Qt::WA_Maemo5AutoOrientation, settings->useAutoRotate()); #endif } @@ -388,10 +560,10 @@ void MainWindow::setSmartReflex() //SmartReflex is only supported on Maemo5 #if defined(Q_WS_MAEMO_5) if ( getSmartReflexState() == 1 ) - callHelper( "set_sr", "off"); + callHelper( "set_sr", "off"); else { - QMaemo5InformationBox::information(this, tr( "SmartReflex support is known to be unstable on some devices and may cause random reboots." ), QMaemo5InformationBox::DefaultTimeout); - callHelper( "set_sr", "on"); + QMaemo5InformationBox::information(this, tr( "SmartReflex support is known to be unstable on some devices and may cause random reboots." ), 0); + callHelper( "set_sr", "on"); } #endif @@ -405,7 +577,17 @@ void MainWindow::setSmartReflex() */ void MainWindow::showHelp() { - helpWindow->show(); + helpWindow.show(); +} + + +/** + * SLOT: displays the settings widget + */ +void MainWindow::showSettings() +{ + settings->reset(); + settings->show(); } @@ -416,7 +598,7 @@ bool MainWindow::usePortrait() { QRect screenGeometry = QApplication::desktop()->screenGeometry(); if (screenGeometry.width() > screenGeometry.height()) - return false; + return false; else - return true; + return true; }