demos/mobile/guitartuner/src/guitartunerui.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2015 The Qt Company Ltd.
   4 ** Contact: http://www.qt.io/licensing/
   5 **
   6 ** This file is part of the QtDeclarative module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:BSD$
   9 ** You may use this file under the terms of the BSD license as follows:
  10 **
  11 ** "Redistribution and use in source and binary forms, with or without
  12 ** modification, are permitted provided that the following conditions are
  13 ** met:
  14 **   * Redistributions of source code must retain the above copyright
  15 **     notice, this list of conditions and the following disclaimer.
  16 **   * Redistributions in binary form must reproduce the above copyright
  17 **     notice, this list of conditions and the following disclaimer in
  18 **     the documentation and/or other materials provided with the
  19 **     distribution.
  20 **   * Neither the name of The Qt Company Ltd nor the names of its
  21 **     contributors may be used to endorse or promote products derived
  22 **     from this software without specific prior written permission.
  23 **
  24 **
  25 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
  36 **
  37 ** $QT_END_LICENSE$
  38 **
  39 ****************************************************************************/
  40
  41 #include <QTimer>
  42
  43 #include "guitartunerui.h"
  44 #include "ui_guitartunerui.h"
  45
  46 GuitarTunerUI::GuitarTunerUI(QWidget *parent) :
  47     QWidget(parent),
  48     ui(new Ui::GuitarTunerUI),
  49     m_maximumPrecision(0)
  50 {
  51     ui->setupUi(this);
  52
  53     // Set up the class attributes to proper values.
  54     m_outputActive = false;
  55     m_muted = false;
  56     m_outputVolumeLevel = getVolumeFromSoundSlider();
  57     m_inputVolumeLevel = 1.0 - m_outputVolumeLevel;
  58
  59     // Set up the current tone, the frequency, and the name for it.
  60     m_currentToneIndex = 5;
  61     updateFrequencyByToneIndex(m_currentToneIndex);
  62
  63     // Connect the signals from UI into proper slots.
  64     connect(ui->soundSlider, SIGNAL(valueChanged(int)),
  65             SLOT(changeVolume()));
  66     connect(ui->soundButton, SIGNAL(toggled(bool)),
  67             SLOT(toggleSound(bool)));
  68     connect(ui->modeButton, SIGNAL(clicked()),
  69             SLOT(toggleInputOrOutput()));
  70     connect(ui->buttonNext, SIGNAL(clicked()), SLOT(next()));
  71     connect(ui->buttonPrev, SIGNAL(clicked()), SLOT(prev()));
  72
  73     // Initialise up the UI by calling toggleInputOrOutput
  74     // for the first time.
  75     toggleInputOrOutput();
  76 }
  77
  78 GuitarTunerUI::~GuitarTunerUI()
  79 {
  80     delete ui;
  81 }
  82
  83 void GuitarTunerUI::changeEvent(QEvent *e)
  84 {
  85     QWidget::changeEvent(e);
  86     switch (e->type()) {
  87     case QEvent::LanguageChange:
  88         ui->retranslateUi(this);
  89         break;
  90     default:
  91         break;
  92     }
  93 }
  94
  95 /**
  96   * Returns a value from 0 to 1, representing the volume.
  97   */
  98 qreal GuitarTunerUI::getVolumeFromSoundSlider() const
  99 {
 100     qreal value = ui->soundSlider->value();
 101     return value/ui->soundSlider->maximum();
 102 }
 103
 104 /**
 105   * Updates the m_currentToneFrequency and m_currentToneString,
 106   * according to the given index. Also updates the UI.
 107   */
 108 void GuitarTunerUI::updateFrequencyByToneIndex(int index)
 109 {
 110
 111     switch (index) {
 112     case 0: {
 113             m_currentToneFrequency = FrequencyE;
 114             m_currentToneString = "E";
 115             break;
 116         }
 117     case 1: {
 118             m_currentToneFrequency = FrequencyA;
 119             m_currentToneString = "A";
 120             break;
 121         }
 122     case 2: {
 123             m_currentToneFrequency = FrequencyD;
 124             m_currentToneString = "D";
 125             break;
 126         }
 127     case 3: {
 128             m_currentToneFrequency = FrequencyG;
 129             m_currentToneString = "G";
 130             break;
 131         }
 132     case 4: {
 133             m_currentToneFrequency = FrequencyB;
 134             m_currentToneString = "B";
 135             break;
 136         }
 137     case 5: {
 138             m_currentToneFrequency = FrequencyE2;
 139             m_currentToneString = "e";
 140             break;
 141         }
 142     default: {
 143             qDebug() << "invalid index!" << index;
 144         }
 145     }
 146     // Set the noteLabel text according to the current tone.
 147     ui->noteLabel->setText(m_currentToneString);
 148 }
 149
 150 /**
 151   * Returns the volume.
 152   */
 153 qreal GuitarTunerUI::getVolume() const
 154 {
 155     return m_outputVolumeLevel;
 156 }
 157
 158 /**
 159   * Returns true if the sound is muted.
 160   */
 161 bool GuitarTunerUI::getMuteState() const
 162 {
 163     return m_muted;
 164 }
 165
 166
 167 /**
 168   * Returns the microphone sensitivity.
 169   */
 170 qreal GuitarTunerUI::getMicrophoneSensitivity() const
 171 {
 172     return m_inputVolumeLevel;
 173 }
 174
 175 /**
 176   * Returns whether the input mode is active.
 177   */
 178 bool GuitarTunerUI::isInputModeActive() const
 179 {
 180     return !m_outputActive;
 181 }
 182
 183 /**
 184   * Returns the current target frequency.
 185   */
 186 qreal GuitarTunerUI::getFrequency() const
 187 {
 188     return m_currentToneFrequency;
 189 }
 190
 191 /**
 192   * Toggles the sound according to the parameter.
 193   * Has no effect if output is not active.
 194   */
 195 void GuitarTunerUI::toggleSound(bool noSound)
 196 {
 197     if (!m_outputActive) {
 198         return;
 199     }
 200     m_muted = noSound;
 201     emit muteChanged(m_muted);
 202 }
 203
 204 /**
 205   * Changes the volume or microphone sensitivity.
 206   */
 207 void GuitarTunerUI::changeVolume()
 208 {
 209     qreal resultingAmplitude = getVolumeFromSoundSlider();
 210     qDebug() << "resultingAmplitude" << resultingAmplitude;
 211     if (m_outputActive) {
 212         m_outputVolumeLevel = resultingAmplitude;
 213         emit volumeChanged(resultingAmplitude);
 214     }
 215     else {
 216         m_inputVolumeLevel = resultingAmplitude;
 217         emit microphoneSensitivityChanged(1.0-resultingAmplitude);
 218     }
 219 }
 220
 221 /**
 222   * Toggles input or output, depending of the current state.
 223   */
 224 void GuitarTunerUI::toggleInputOrOutput()
 225 {
 226     // If output mode is active:
 227     if (m_outputActive) {
 228         // Change UI to correspond to the input mode.
 229         m_outputActive = false;
 230         ui->soundSlider->setValue(m_inputVolumeLevel*100);
 231         ui->soundButton->setDisabled(true);
 232         ui->soundButton->hide();
 233         ui->micSensitivityLabel->show();
 234         emit modeChanged(true);
 235         ui->modeButton->setText("To tone mode");
 236     }
 237     // Else:
 238     else {
 239         // Change UI to correspond to the output mode.
 240         m_outputActive = true;
 241         ui->soundSlider->setValue(m_outputVolumeLevel*100);
 242         ui->soundButton->setDisabled(false);
 243         ui->micSensitivityLabel->hide();
 244         ui->soundButton->show();
 245         emit modeChanged(false);
 246         ui->modeButton->setText("To listen mode");
 247     }
 248 }
 249
 250 /**
 251   * Receives the low voice signal.
 252   */
 253 void GuitarTunerUI::lowVoice()
 254 {
 255     if (ui->noteLabel->font().bold()) {
 256         QFont font;
 257         font.setBold(false);
 258         font.setUnderline(false);
 259         ui->noteLabel->setFont(font);
 260     }
 261 }
 262
 263 /**
 264   * Receives the voice difference signal.
 265   * The difference is qreal, where increase of 1 corresponds
 266   * to increase of 1 tone to the target frequency.
 267   */
 268 void GuitarTunerUI::voiceDifference(qreal difference)
 269 {
 270     if (ui->noteLabel->font().bold()) {
 271         QFont font;
 272         font.setBold(false);
 273         font.setUnderline(false);
 274         ui->noteLabel->setFont(font);
 275     }
 276     ui->correctSoundSlider->setValue(difference*m_maximumPrecision);
 277 }
 278
 279 /**
 280   * Receives the correct frequency signal.
 281   * Makes the UI to visualize correct frequency event.
 282   */
 283 void GuitarTunerUI::correctFrequencyObtained()
 284 {
 285     qDebug() << "CORRECT FREQUENCY";
 286     QFont font;
 287     font.setBold(true);
 288     font.setUnderline(true);
 289     ui->noteLabel->setFont(font);
 290 }
 291
 292 /**
 293   * Sets up the maximum voice difference.
 294   */
 295 void GuitarTunerUI::setMaximumVoiceDifference(int max)
 296 {
 297     // Assert that the maximum precision is known.
 298     Q_ASSERT(m_maximumPrecision != 0);
 299     // Set the maximum and minimum values of the correctSoundSlider
 300     // to the +- max*m_maximumPrecision, and set the tick interval
 301     // to be m_maximumPrecision.
 302     ui->correctSoundSlider->setMaximum(max*m_maximumPrecision);
 303     ui->correctSoundSlider->setMinimum(-max*m_maximumPrecision);
 304     ui->correctSoundSlider->setTickInterval(max*m_maximumPrecision);
 305 }
 306
 307 /**
 308   * Stores the maximum precision per note. Used to setup the
 309   * correct sound slider.
 310   */
 311 void GuitarTunerUI::setMaximumPrecisionPerNote(int max)
 312 {
 313     m_maximumPrecision = max;
 314 }
 315
 316 /**
 317   * Changes the tone to the next value.
 318   */
 319 void GuitarTunerUI::next()
 320 {
 321     changeTone((m_currentToneIndex + 1) % 6);
 322 }
 323
 324 /**
 325   * Changes the tone to the previous value.
 326   */
 327 void GuitarTunerUI::prev()
 328 {
 329     changeTone((m_currentToneIndex + 5) % 6);
 330 }
 331
 332 /**
 333   * Changes the tone according to the new index.
 334   */
 335 void GuitarTunerUI::changeTone(int newIndex)
 336 {
 337     m_currentToneIndex = newIndex;
 338     updateFrequencyByToneIndex(m_currentToneIndex);
 339     qDebug() << "targetFrequencyChanged" << m_currentToneFrequency;
 340     emit targetFrequencyChanged(m_currentToneFrequency);
 341 }