#include "manualcookwindow.h"
  #include "ui_manualcookwindow.h"
  
  #include <QSignalMapper>
  #include <QTimer>
  #include <QtDebug>

  #include "soundplayer.h"

  #include "preheatpopup.h"

  #include "cooldownpopup.h"

  #include "cookhistory.h"
  #include "favoritenamepopup.h"
  #include "confirmpopup.h"

  #include "stringer.h"
  #include "config.h"

  #include "coretempsettingpopup.h"

  #include "reservetimepopup.h"
  #include "reservedtimepopup.h"

  #include "mainwindow.h"
  #include "configwindow.h"
  #include "primewindow.h"
  #include "washwindow.h"

  #include "errorpopupdlg.h"

  #include <QTime>

  ManualCookWindow::ManualCookWindow(QWidget *parent, Define::Mode mode) :

      QMainWindow(parent),

      ui(new Ui::ManualCookWindow),
      repeat(false)

  {
      ui->setupUi(this);

      ui->clockContainer->setParent(ui->upperStack);

      ui->closeDoorWidget->setParent(ui->upperStack);

      setAttribute(Qt::WA_DeleteOnClose);

      oven = Oven::getInstance();

      ui->humiditySlider->setSubPixmap(":/images/slider/humidity.png");
      ui->humiditySlider->setRange(0, 100);
      ui->humiditySlider->bigTickInterval = 50;
      ui->humiditySlider->tickInterval = 10;
  
      ui->tempSlider->setSubPixmap(":/images/slider/temp.png");
      ui->tempSlider->bigTickInterval = 50;
      ui->tempSlider->tickInterval = 10;
  
      ui->timeSlider->setSubPixmap(":/images/slider/time.png");
      ui->timeSlider->setRange(0, 342);
      ui->timeSlider->bigTicks.append(0);
      ui->timeSlider->bigTicks.append(180);
      ui->timeSlider->bigTicks.append(270);
      ui->timeSlider->bigTicks.append(342);
      ui->timeSlider->ticks.append(60);
      ui->timeSlider->ticks.append(120);
      ui->timeSlider->ticks.append(180 + 30);
      ui->timeSlider->ticks.append(180 + 60);
      ui->timeSlider->ticks.append(270 + 4 * 6);
      ui->timeSlider->ticks.append(270 + 4 * 12);
  
      ui->interTempSlider->setSubPixmap(":/images/slider/core.png");
  
      QList<int> &bigTicks = ui->interTempSlider->bigTicks;
      bigTicks.append(oven->minInterTemp());
      bigTicks.append(oven->minInterTemp() + (oven->maxInterTemp() - oven->minInterTemp()) / 2);
      bigTicks.append(oven->maxInterTemp());
  
      QList<int> &ticks = ui->interTempSlider->ticks;
      for (int i = 1; i < 3; i++)
          ticks.append(bigTicks.at(0) + i * (bigTicks.at(1) - bigTicks.at(0)) / 3);
      for (int i = 1; i < 3; i++)
          ticks.append(bigTicks.at(1) + i * (bigTicks.at(2) - bigTicks.at(1)) / 3);

      lastViewHumidity = -1;
      lastViewTemp = -1;
      lastViewTime = -1;
      lastViewInterTemp = -1;
      lastViewInterTempEnabled = !oven->interTempEnabled();
      lastViewCooking = false;
      lastViewDamper = false;
      lastViewHumidification = false;
      lastViewFan = -1;

      lastCheckedCooking = false;

      Config *config = Config::getInstance();
      config_item item = config->getConfigValue(Define::config_cooking_door_monitoring);
  
      monitorLevel = item.d8.d8_0;
      if (monitorLevel > 0 && monitorLevel < 4)
      {
          monitor1.setSingleShot(true);
          monitor2.setSingleShot(true);
          monitor3.setSingleShot(true);
          monitor1.setInterval(item.d8.d8_1 * 1000);
          monitor2.setInterval(item.d8.d8_2 * 1000);
          monitor3.setInterval(item.d8.d8_3 * 1000);
          connect(&monitor1, SIGNAL(timeout()), SLOT(onMonitor1Timeout()));
          connect(&monitor2, SIGNAL(timeout()), SLOT(onMonitor2Timeout()));
          connect(&monitor3, SIGNAL(timeout()), SLOT(onMonitor3Timeout()));
      }
      else
          monitorLevel = 0;

      connect(ui->humiditySlider, SIGNAL(valueChanged(int)), oven, SLOT(setHumidity(int)));
      connect(ui->tempSlider, SIGNAL(valueChanged(int)), oven, SLOT(setTemp(int)));

      connect(ui->timeSlider, SIGNAL(valueChanged(int)), &startCookingTimer, SLOT(start()));

      connect(ui->timeSlider, SIGNAL(valueChanged(int)), this, SLOT(updateView()));

      connect(ui->interTempSlider, SIGNAL(valueChanged(int)), oven, SLOT(setInterTemp(int)));

      connect(ui->humiditySlider, SIGNAL(sliderMoved(int)), this, SLOT(updateView()));
      connect(ui->tempSlider, SIGNAL(sliderMoved(int)), this, SLOT(updateView()));
      connect(ui->timeSlider, SIGNAL(sliderMoved(int)), this, SLOT(updateView()));
      connect(ui->interTempSlider, SIGNAL(sliderMoved(int)), this, SLOT(updateView()));

      startCookingTimer.setSingleShot(true);

      startCookingTimer.setInterval(3000);

      connect(&startCookingTimer, SIGNAL(timeout()), SLOT(start()));
  
      showCurrentHumidityTimer.setSingleShot(true);

      showCurrentHumidityTimer.setInterval(1000);

      connect(&showCurrentHumidityTimer, SIGNAL(timeout()), SLOT(showCurrentHumidity()));
  
      showCurrentTempTimer.setSingleShot(true);

      showCurrentTempTimer.setInterval(1000);

      connect(&showCurrentTempTimer, SIGNAL(timeout()), SLOT(showCurrentTemp()));

      focusHumidityButtonTimer.setSingleShot(true);
      focusHumidityButtonTimer.setInterval(3000);
      connect(&focusHumidityButtonTimer, SIGNAL(timeout()), SLOT(focusHumidityButton()));
  
      focusTempButtonTimer.setSingleShot(true);
      focusTempButtonTimer.setInterval(3000);
      connect(&focusTempButtonTimer, SIGNAL(timeout()), SLOT(focusTempButton()));
  
      focusTimeButtonTimer.setSingleShot(true);
      focusTimeButtonTimer.setInterval(3000);
      connect(&focusTimeButtonTimer, SIGNAL(timeout()), SLOT(focusTimeButton()));
  
      focusInterTempButtonTimer.setSingleShot(true);
      focusInterTempButtonTimer.setInterval(3000);
      connect(&focusInterTempButtonTimer, SIGNAL(timeout()), SLOT(focusInterTempButton()));
  
      connect(ui->humiditySlider, SIGNAL(sliderMoved(int)), &focusHumidityButtonTimer, SLOT(start()));
      connect(ui->tempSlider, SIGNAL(sliderMoved(int)), &focusTempButtonTimer, SLOT(start()));
      connect(ui->timeSlider, SIGNAL(sliderMoved(int)), &focusTimeButtonTimer, SLOT(start()));
      connect(ui->interTempSlider, SIGNAL(sliderMoved(int)), &focusInterTempButtonTimer, SLOT(start()));

      connect(oven, SIGNAL(changed(Oven*)), this, SLOT(onOvenUpdated(Oven*)));

      oven->setDefault(mode);

      connect(&updateViewTimer, SIGNAL(timeout()), SLOT(updateView()));
      updateViewTimer.start(100);

      foreach (QPushButton *button, findChildren<QPushButton *>())

          connect(button, &QPushButton::pressed, SoundPlayer::playClick);

  
      QTimer::singleShot(0, this, SLOT(setupAnimation()));

  
      setFocus();

  }

  ManualCookWindow::ManualCookWindow(QWidget *parent, ManualCookSetting setting)
      : ManualCookWindow(parent, setting.mode)
  {
      oven->setHumidity(setting.humidity);
      oven->setTemp(setting.temp);
      oven->setTime(setting.time);
      oven->setFan(setting.fan);
      oven->setInterTempEnabled(setting.coreTempEnabled);
      oven->setInterTemp(setting.coreTemp);
  
      startCookingTimer.start();
  
      onOvenUpdated(oven);
  }

  ManualCookWindow::~ManualCookWindow()
  {

      stop();

      delete ui;
  }

  void ManualCookWindow::keyPressEvent(QKeyEvent *event)
  {
      switch (event->key())
      {
      case 0x01000030:    // Turn left
          onEncoderLeft();
          break;
      case 0x01000031:    // Push
          if (focusWidget() != this)
          {
              pushed = focusWidget();
  
              if (pushed == ui->humidityButton)
                  on_humidityButton_pressed();
              else if (pushed == ui->tempButton)
                  on_tempButton_pressed();
  
          }
          break;
      case 0x01000032:    // Turn right
          onEncoderRight();
          break;
      }
  }
  
  void ManualCookWindow::keyReleaseEvent(QKeyEvent *event)
  {
      switch (event->key())
      {
      case 0x01000030:    // Turn left
          onEncoderLeft();
          break;
      case 0x01000031:    // Push

          if (pushed == ui->humidityButton)

              on_humidityButton_released();

          else if (pushed == ui->tempButton)

              on_tempButton_released();
  
          if (focusWidget() == pushed)
              onEncoderClicked(pushed);
  
          pushed = NULL;
          break;
      case 0x01000032:    // Turn right
          onEncoderRight();
          break;
      }
  }

  void ManualCookWindow::setupAnimation()
  {

      ui->openDoorAnimation->load(":/images/animation/door_big_09.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_08.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_07.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_06.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_05.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_04.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_03.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_02.png");
      ui->openDoorAnimation->load(":/images/animation/door_big_01.png");
      ui->openDoorAnimation->start(300);

  }

  void ManualCookWindow::updateView()

  {

      switch (oven->mode())

      {

      case Define::DryMode:

          if (ui->steamButton->isChecked())
              ui->steamButton->setChecked(false);
          if (ui->combiButton->isChecked())
              ui->combiButton->setChecked(false);

          if (!ui->dryheatButton->isChecked())
              ui->dryheatButton->setChecked(true);
          break;
      case Define::SteamMode:
          if (!ui->steamButton->isChecked())
              ui->steamButton->setChecked(true);

          if (ui->combiButton->isChecked())
              ui->combiButton->setChecked(false);
          if (ui->dryheatButton->isChecked())
              ui->dryheatButton->setChecked(false);

          break;
      case Define::CombiMode:

          if (ui->steamButton->isChecked())
              ui->steamButton->setChecked(false);

          if (!ui->combiButton->isChecked())
              ui->combiButton->setChecked(true);

          if (ui->dryheatButton->isChecked())
              ui->dryheatButton->setChecked(false);

          break;
      default:
          break;

      }

      QWidget *focused = focusWidget();
      ui->humidityButton->setChecked(focused == ui->humiditySlider);
      ui->tempButton->setChecked(focused == ui->tempSlider);
      ui->timeButton->setChecked(focused == ui->timeSlider);

      int humidity;
      if (showCurrentHumidity_)
          humidity = oven->currentHumidity();

      else if (ui->humiditySlider->isSliderDown() || focusWidget() == ui->humiditySlider)

          humidity = ui->humiditySlider->sliderPosition();
      else
          humidity = oven->humidity();

      if (humidity != lastViewHumidity)
      {
          lastViewHumidity = humidity;
  
          bool old = ui->humiditySlider->blockSignals(true);
          if (ui->humiditySlider->sliderPosition() != humidity)
              ui->humiditySlider->setValue(humidity);
          ui->humiditySlider->setEnabled(oven->mode() == Define::CombiMode);
          ui->humiditySlider->blockSignals(old);
  
          ui->humidityLabel->setText(QString("%1%").arg(humidity));
      }

  
      int temp;
      if (showCurrentTemp_)
          temp = oven->currentTemp();

      else if (ui->tempSlider->isSliderDown() || focusWidget() == ui->tempSlider)

          temp = ui->tempSlider->sliderPosition();
      else
          temp = oven->temp();

      if (temp != lastViewTemp)
      {
          lastViewTemp = temp;

          ui->tempLabel->setText(Stringer::temperature(temp, Stringer::fontSize14));
      }

      bool old = ui->tempSlider->blockSignals(true);
      ui->tempSlider->setRange(oven->minTemp(), oven->maxTemp());
      if (ui->tempSlider->sliderPosition() != temp)
          ui->tempSlider->setValue(temp);
      ui->tempSlider->blockSignals(old);

      int msecs = oven->msecs();
      if (ui->timeSlider->isSliderMoved())
          ui->timeLabel->setText(Stringer::remainingTime(sliderToTime(ui->timeSlider->sliderPosition()) * 1000, Stringer::fontSize14));

      else

          ui->timeLabel->setText(Stringer::remainingTime(msecs, Stringer::fontSize14));

      if (focusWidget() != ui->timeSlider)

      {

          bool old = ui->timeSlider->blockSignals(true);

          ui->timeSlider->setSliderPosition(timeToSlider(msecs / 1000));

          ui->timeSlider->blockSignals(old);

      }

      int interTemp;

      if (ui->interTempSlider->isSliderDown() || focusWidget() == ui->interTempSlider)

          interTemp = ui->interTempSlider->sliderPosition();
      else
          interTemp = oven->interTemp();

      ui->interTempButton->setChecked(oven->interTempEnabled());

      bool interTempEnabled = oven->interTempEnabled();
      if (interTempEnabled != lastViewInterTempEnabled || interTemp != lastViewInterTemp)

      {

          if (interTempEnabled != lastViewInterTempEnabled)

  //        {

              lastViewInterTempEnabled = oven->interTempEnabled();

  //            ui->interTempButton->setChecked(interTempEnabled);
  //        }

          lastViewInterTemp = interTemp;

          bool old = ui->interTempSlider->blockSignals(true);
          ui->interTempSlider->setEnabled(interTempEnabled);

          ui->interTempSlider->setSubVisible(interTempEnabled);

          ui->interTempSlider->setRange(oven->minInterTemp(), oven->maxInterTemp());

          if (ui->interTempSlider->sliderPosition() != interTemp)
              ui->interTempSlider->setValue(interTemp);

          ui->interTempSlider->blockSignals(old);

          if (interTempEnabled)
              ui->interTempLabel->setText(Stringer::temperature(interTemp, Stringer::fontSize14));
          else
              ui->interTempLabel->setText(Stringer::unusedTemperature(Stringer::fontSize14));
      }

      bool cooking = oven->cooking();
      if (cooking != lastViewCooking)
      {
          lastViewCooking = cooking;

          if (cooking)
              ui->runStopButton->setStyleSheet(
                          "border-image: url(:/images/manual_button/stop.png)");
          else
              ui->runStopButton->setStyleSheet(
                          "border-image: url(:/images/manual_button/run.png)");
      }

      if (showFrontButtons)

      {

          ui->preheatButton->show();
          ui->damperButton->show();
          ui->humidificationButton->show();
          if (oven->cooking())
              ui->repeatButton->show();

          else

              ui->repeatButton->hide();

          ui->cooldownButton->hide();
          ui->fanButton->hide();
          ui->reserveButton->hide();
          ui->favoriteButton->hide();
      }
      else

      {

          ui->preheatButton->hide();
          ui->damperButton->hide();
          ui->humidificationButton->hide();
          ui->repeatButton->hide();

          ui->cooldownButton->show();
          ui->fanButton->show();
          if (oven->cooking())
          {
              ui->reserveButton->hide();
              ui->favoriteButton->hide();
          }

          else

          {
              ui->reserveButton->show();
              ui->favoriteButton->show();
          }

      }

      bool damper = oven->damper();
      ui->damperButton->setChecked(damper);

  
      bool humidification = oven->humidification();
      ui->humidificationButton->setChecked(humidification);

      int fan = oven->fan();
      if (fan != lastViewFan)
      {
          lastViewFan = fan;
  
          switch (fan)
          {
          case 1:
              ui->fanButton->setStyleSheet(
                          "background-image: url(:/images/manual_button/fan_1.png)");
              break;
          case 2:
              ui->fanButton->setStyleSheet(
                          "background-image: url(:/images/manual_button/fan_2.png)");
              break;
          case 3:
              ui->fanButton->setStyleSheet(
                          "background-image: url(:/images/manual_button/fan_3.png)");
              break;
          case 4:
              ui->fanButton->setStyleSheet(
                          "background-image: url(:/images/manual_button/fan_4.png)");
              break;
          case 5:
              ui->fanButton->setStyleSheet(
                          "background-image: url(:/images/manual_button/fan_5.png)");
              break;
          default:
              ui->fanButton->setStyleSheet(
                          "background-image: url(:/images/manual_button/fan_1.png)");
              break;
          }

      }

      if (oven->paused() && !oven->cooldown() && oven->door())
          ui->upperStack->setCurrentIndex(1);
      else
          ui->upperStack->setCurrentIndex(0);

  }
  
  void ManualCookWindow::showCurrentHumidity()
  {
      showCurrentHumidity_ = true;
      updateView();
  }
  
  void ManualCookWindow::hideCurrentHumidity()
  {
      showCurrentHumidity_ = false;
      updateView();
  }
  
  void ManualCookWindow::showCurrentTemp()
  {
      showCurrentTemp_ = true;
      updateView();
  }
  
  void ManualCookWindow::hideCurrentTemp()
  {
      showCurrentTemp_ = false;
      updateView();
  }
  
  void ManualCookWindow::onOvenUpdated(Oven *oven)
  {
      updateView();
  
      if (oven->interTempEnabled() && oven->currentInterTemp() >= oven->interTemp())

          stop();

  
      if (repeat && !oven->cooking())
      {
          repeat = false;
  
          ui->repeatButton->setStyleSheet("\
  QPushButton { background-image: url(:/images/manual_button/repeat.png); }\
  QPushButton:pressed { background-image: url(:/images/manual_button/repeat_ov.png); }");
  
          oven->setMode(repeatSetting.mode);
          oven->setHumidity(repeatSetting.humidity);
          oven->setTemp(repeatSetting.temp);
          oven->setTime(repeatSetting.time);
          oven->setInterTempEnabled(repeatSetting.coreTempEnabled);
          oven->setInterTemp(repeatSetting.coreTemp);
      }

      else if (lastCheckedCooking && !oven->cooking()){
          if ((oven->interTempEnabled() && oven->currentInterTemp() >= oven->interTemp())
                  || oven->time() == 0)
          {
              lastCheckedCooking = oven->cooking();
              emit done();
          }
      }
  
      lastCheckedCooking = oven->cooking();

  
      if (oven->paused() && oven->door())
      {
          if (monitorLevel > 0 && !monitorTriggered)
          {
              monitorTriggered = true;
              monitor1.start();
          }
      }
  
      if (monitorTriggered && !oven->door())
      {
          monitorTriggered = false;
          monitor1.stop();
          monitor2.stop();
          monitor3.stop();
      }

  }

  void ManualCookWindow::setOvenDefault(Define::Mode mode)

  {

      stop();
  
      oven->setDefault(mode);

  }
  
  void ManualCookWindow::start()
  {

      if (oven->cooking())
          return;

      if (oven->time() > 0)
      {

          SoundPlayer::playStart();

          if (startCookingTimer.isActive())
              startCookingTimer.stop();
  
          oven->startCooking();

  
          ManualCookSetting s;
          s.mode = oven->mode();
          s.humidity = oven->humidity();
          s.temp = oven->temp();
          s.time = oven->time();
          s.fan = oven->fan();
          s.coreTempEnabled = oven->interTempEnabled();
          s.coreTemp = oven->interTemp();
  
          CookHistory::record(s);

  
          if (monitorLevel > 0 && oven->door())
          {
              monitorTriggered = true;
              monitor1.start();
          }
          else
              monitorTriggered = false;

      }

  }
  
  void ManualCookWindow::stop()
  {

      if (oven->cooking())
          SoundPlayer::playStop();

      oven->stop();
      startCookingTimer.stop();

  }

  void ManualCookWindow::addFavorite()
  {
      ManualCookSetting s;
      s.mode = oven->mode();
      s.humidity = oven->humidity();
      s.temp = oven->temp();
      s.time = oven->time();
      s.fan = oven->fan();
      s.coreTempEnabled = oven->interTempEnabled();
      s.coreTemp = oven->interTemp();
  
      FavoriteNamePopup *p = new FavoriteNamePopup(this, s);
      p->showFullScreen();
  }
  
  void ManualCookWindow::jumpConfig()
  {
      stop();
  
      ConfigWindow *w = new ConfigWindow(MainWindow::getInstance());
      w->setWindowModality(Qt::WindowModal);
      w->showFullScreen();
      w->raise();
  
      MainWindow::jump(w);
  }
  
  void ManualCookWindow::jumpFavorites()
  {
      stop();
  
      PrimeWindow *w = new PrimeWindow(MainWindow::getInstance());
      w->setWindowModality(Qt::WindowModal);
      w->listFavorites();
      w->showFullScreen();
      w->raise();
  
      MainWindow::jump(w);
  }
  
  void ManualCookWindow::jumpWash()
  {
      stop();
  
      WashWindow *w = new WashWindow(MainWindow::getInstance());
      w->setWindowModality(Qt::WindowModal);
      w->showFullScreen();
      w->raise();
  
      MainWindow::jump(w);
  }

  void ManualCookWindow::onMonitor1Timeout()
  {
      SoundPlayer::playError1();

      ErrorPopupDlg *d = new ErrorPopupDlg(this, tr("문을 닫아주세요"), tr("조리 중 문 열림 시간 모니터링 1단계"));

      d->showFullScreen();
  
      if (monitorLevel > 1)
          monitor2.start();
  }
  
  void ManualCookWindow::onMonitor2Timeout()
  {
      SoundPlayer::playError1();

      ErrorPopupDlg *d = new ErrorPopupDlg(this, tr("문을 닫아주세요"), tr("조리 중 문 열림 시간 모니터링 2단계"));

      d->showFullScreen();
  
      if (monitorLevel > 2)
          monitor3.start();
  }
  
  void ManualCookWindow::onMonitor3Timeout()
  {
      SoundPlayer::playError1();

      ErrorPopupDlg *d = new ErrorPopupDlg(MainWindow::getInstance(), tr("문이 오래 열려있어 조리가 취소되었습니다"), tr("조리 중 문 열림 시간 모니터링 3단계"));

      d->showFullScreen();
      close();
  }

  void ManualCookWindow::onEncoderLeft()
  {
      QWidget *focused = focusWidget();
      if (focused == NULL)
          focusPreviousChild();
      else if (focused == this || focused->inherits("QPushButton"))
      {
          focusPreviousChild();
          focused = focusWidget();
  
          if (focused == ui->steamButton)
          {
              if (oven->mode() == Define::SteamMode)
                  focusPreviousChild();
          }
          else if (focused == ui->combiButton)
          {
              if (oven->mode() == Define::CombiMode)
                  focusPreviousChild();
          }
          else if (focused == ui->dryheatButton)
          {
              if (oven->mode() == Define::DryMode)
                  focusPreviousChild();
          }
      }
  }
  
  void ManualCookWindow::onEncoderRight()
  {
      QWidget *focused = focusWidget();
      if (focused == NULL)
          focusNextChild();
      else if (focused == this)
      {
          switch (oven->mode())
          {
          case Define::DryMode:
          case Define::SteamMode:
              ui->tempButton->setFocus();
              break;
          default:
              ui->humidityButton->setFocus();
          }
      }
      else if (focused->inherits("QPushButton"))
      {
          focusNextChild();
          focused = focusWidget();
  
          if (focused == ui->steamButton)
          {
              if (oven->mode() == Define::SteamMode)
                  focusNextChild();
          }
          else if (focused == ui->combiButton)
          {
              if (oven->mode() == Define::CombiMode)
                  focusNextChild();
          }
          else if (focused == ui->dryheatButton)
          {
              if (oven->mode() == Define::DryMode)
                  focusNextChild();
          }
      }
  }
  
  void ManualCookWindow::onEncoderClicked(QWidget *clicked)
  {
      QWidget *focused = clicked;
      if (focused == NULL)
          return;
  
      if (focused->inherits("QPushButton"))
      {
          QPushButton *pb = qobject_cast<QPushButton *>(focused);
          if (pb)
          {
              pb->click();
  
              if (pb == ui->steamButton || pb == ui->dryheatButton)
                  ui->tempButton->setFocus();
              else if (pb == ui->combiButton)
                  ui->humidityButton->setFocus();
          }
      }
      else if (focused->inherits("Slider"))
      {
          Slider *slider = qobject_cast<Slider *>(focused);
          if (slider)
          {
              if (slider->value() != slider->sliderPosition())
                  slider->setValue(slider->sliderPosition());
  
              if (slider == ui->humiditySlider)
                  ui->humidityButton->setFocus();
              else if (slider == ui->tempSlider)
                  ui->tempButton->setFocus();
              else if (slider == ui->timeSlider)
                  ui->timeButton->setFocus();
              else if (slider == ui->interTempSlider)
                  ui->interTempButton->setFocus();
          }
      }
  }
  
  void ManualCookWindow::focusHumidityButton()
  {
      if (focusWidget() == ui->humiditySlider)
      {
          oven->setHumidity(ui->humiditySlider->value());
          ui->humidityButton->setFocus();
      }
  }
  
  void ManualCookWindow::focusTempButton()
  {
      if (focusWidget() == ui->tempSlider)
      {
          oven->setTemp(ui->tempSlider->value());
          ui->tempButton->setFocus();
      }
  }
  
  void ManualCookWindow::focusTimeButton()
  {
      if (focusWidget() == ui->timeSlider)
      {
          if (ui->timeSlider->isSliderMoved())
              oven->setTime(sliderToTime(ui->timeSlider->value()));
          ui->timeButton->setFocus();
      }
  }
  
  void ManualCookWindow::focusInterTempButton()
  {
      if (focusWidget() == ui->interTempSlider)
      {
          oven->setInterTemp(ui->interTempSlider->value());
          ui->interTempButton->setFocus();
      }
  }
  
  void ManualCookWindow::focusAgain()
  {
      if (focused)
      {
          focused->setFocus();
          focused = NULL;
      }
  }

  void ManualCookWindow::on_steamButton_clicked()
  {

      setOvenDefault(Define::SteamMode);

  }
  
  void ManualCookWindow::on_combiButton_clicked()
  {

      setOvenDefault(Define::CombiMode);

  }
  
  void ManualCookWindow::on_dryheatButton_clicked()
  {

      setOvenDefault(Define::DryMode);

  }
  
  void ManualCookWindow::on_humidityButton_pressed()
  {
      showCurrentHumidityTimer.start();
  }
  
  void ManualCookWindow::on_humidityButton_released()
  {
      if (showCurrentHumidityTimer.isActive())
          showCurrentHumidityTimer.stop();

      else

          hideCurrentHumidity();

  }

  void ManualCookWindow::on_tempButton_pressed()

  {

      showCurrentTempTimer.start();
  }

  void ManualCookWindow::on_tempButton_released()
  {
      if (showCurrentTempTimer.isActive())
          showCurrentTempTimer.stop();
      else
          hideCurrentTemp();
  }

  void ManualCookWindow::on_humidityButton_clicked()
  {
      ui->humiditySlider->setFocus();
  
      focusHumidityButtonTimer.start();
  }
  
  void ManualCookWindow::on_tempButton_clicked()
  {
      ui->tempSlider->setFocus();
  
      focusTempButtonTimer.start();
  }
  
  void ManualCookWindow::on_timeButton_clicked()
  {
      ui->timeSlider->setFocus();
  
      focusTimeButtonTimer.start();
  }

  void ManualCookWindow::on_interTempButton_clicked()
  {
      if (oven->interTempEnabled())
          oven->setInterTempEnabled(false);
      else

      {
          CoreTempSettingPopup *p = new CoreTempSettingPopup(this);
          p->show();

  
          focused = ui->interTempButton;
          connect(p, SIGNAL(destroyed(QObject*)), SLOT(focusAgain()));

      }

  }

  void ManualCookWindow::on_runStopButton_clicked()

  {

      if (oven->cooking())

          stop();

      else

          start();

  }
  
  void ManualCookWindow::on_fanButton_clicked()
  {
      int fan = oven->fan() + 1;
      if (fan > oven->maxFan())
          fan = oven->minFan();
  
      oven->setFan(fan);

  }
  
  void ManualCookWindow::on_preheatButton_clicked()
  {

      startCookingTimer.stop();

      PreheatPopup *p = new PreheatPopup(this, oven);
      p->setWindowModality(Qt::WindowModal);
      p->showFullScreen();

  
      focused = ui->preheatButton;
      connect(p, SIGNAL(destroyed(QObject*)), SLOT(focusAgain()));

  }
  
  void ManualCookWindow::on_damperButton_clicked()
  {

      if (oven->damper())
          oven->closeDamper();

      else

          oven->openDamper();

  }
  
  void ManualCookWindow::on_humidificationButton_clicked()
  {

      if (oven->humidification())
          oven->stopHumidification();

      else

          oven->startHumidification();

  }
  
  void ManualCookWindow::on_repeatButton_clicked()
  {

      if (repeat)
      {
          repeat = false;
          ui->repeatButton->setStyleSheet("\
  QPushButton { background-image: url(:/images/manual_button/repeat.png); }\
  QPushButton:pressed { background-image: url(:/images/manual_button/repeat_ov.png); }");
      }
      else
      {
          repeat = true;
          ui->repeatButton->setStyleSheet("\
  QPushButton { background-image: url(:/images/manual_button/repeat_ov.png); }\
  QPushButton:pressed { background-image: url(:/images/manual_button/repeat.png); }");
          repeatSetting.mode = oven->mode();
          repeatSetting.humidity = oven->humidity();
          repeatSetting.temp= oven->temp();
          repeatSetting.time = oven->time();
          repeatSetting.coreTempEnabled = oven->interTempEnabled();
          repeatSetting.coreTemp = oven->interTemp();
      }

  }
  
  void ManualCookWindow::on_cooldownButton_clicked()
  {

      startCookingTimer.stop();

  
      CooldownPopup *p = new CooldownPopup(this, oven);
      p->setWindowModality(Qt::WindowModal);
      p->showFullScreen();

  
      focused = ui->cooldownButton;
      connect(p, SIGNAL(destroyed(QObject*)), SLOT(focusAgain()));

  }
  
  void ManualCookWindow::on_reserveButton_clicked()
  {

      if (oven->time() > 0)
      {
          startCookingTimer.stop();
  
          ReserveTimePopup *p = new ReserveTimePopup(this);
          connect(p, SIGNAL(timeout()), SLOT(start()));
          connect(p, SIGNAL(canceled()), &startCookingTimer, SLOT(start()));
          p->showFullScreen();

  
          focused = ui->reserveButton;
          connect(p, SIGNAL(destroyed(QObject*)), SLOT(focusAgain()));

      }

  }

  void ManualCookWindow::on_favoriteButton_clicked()

  {

      if (oven->cooking())
          return;
  
      ConfirmPopup *p = new ConfirmPopup(this, tr("즐겨찾기 항목에 추가하시겠습니까?"));
      p->showFullScreen();

      focused = ui->favoriteButton;

      connect(p, SIGNAL(rejected()), SLOT(focusAgain()));

      connect(p, SIGNAL(accepted()), SLOT(addFavorite()));
  
      if (startCookingTimer.isActive())
      {
          startCookingTimer.stop();
          connect(p, SIGNAL(rejected()), &startCookingTimer, SLOT(start()));
      }

  }

  void ManualCookWindow::on_goFrontStackButton_clicked()
  {

      showFrontButtons = !showFrontButtons;
  
      updateView();

  }
  
  void ManualCookWindow::on_backButton_clicked()
  {
      stop();
      close();
  }

  void ManualCookWindow::on_configButton_clicked()
  {
      if (oven->cooking())
      {
          ConfirmPopup *p = new ConfirmPopup(this, tr("요리가 중단되고 환경 설정 모드로 들어갑니다. 진행할까요?"));
          p->showFullScreen();
  
          connect(p, SIGNAL(accepted()), SLOT(jumpConfig()));

  
          focused = ui->configButton;
          connect(p, SIGNAL(destroyed(QObject*)), SLOT(focusAgain()));

      }
      else
      {
          ConfigWindow *w = new ConfigWindow(MainWindow::getInstance());
          w->setWindowModality(Qt::WindowModal);
          w->showFullScreen();
          w->raise();
  
          MainWindow::jump(w);
      }
  }
  
  void ManualCookWindow::on_favoritesButton_clicked()
  {
      if (oven->cooking())
      {
          ConfirmPopup *p = new ConfirmPopup(this, tr("요리가 중단되고 즐겨찾기 모드로 들어갑니다. 진행할까요?"));
          p->showFullScreen();
  
          connect(p, SIGNAL(accepted()), SLOT(jumpFavorites()));

  
          focused = ui->favoritesButton;
          connect(p, SIGNAL(destroyed(QObject*)), SLOT(focusAgain()));

      }
      else
      {
          PrimeWindow *w = new PrimeWindow(MainWindow::getInstance());
          w->setWindowModality(Qt::WindowModal);
          w->listFavorites();
          w->showFullScreen();
          w->raise();
  
          MainWindow::jump(w);
      }
  }
  
  void ManualCookWindow::on_washButton_clicked()
  {
      if (oven->cooking())
      {
          ConfirmPopup *p = new ConfirmPopup(this, tr("요리가 중단되고 자동 세척 모드로 들어갑니다. 진행할까요?"));
          p->showFullScreen();
  
          connect(p, SIGNAL(accepted()), SLOT(jumpWash()));

  
          focused = ui->washButton;
          connect(p, SIGNAL(destroyed(QObject*)), SLOT(focusAgain()));

      }
      else
      {
          WashWindow *w = new WashWindow(MainWindow::getInstance());
          w->setWindowModality(Qt::WindowModal);
          w->showFullScreen();
          w->raise();
  
          MainWindow::jump(w);
      }
  }
  
  void ManualCookWindow::on_helpButton_clicked()

  {

  }

  
  void ManualCookWindow::on_timeSlider_valueChanged()
  {
      oven->setTime(sliderToTime(ui->timeSlider->value()));
  }
  
  int ManualCookWindow::sliderToTime(int value)
  {
      if (value <= 180)
          return value * 60;
      if (value <= 270)
          return 180 * 60 + (value - 180) * 2 * 60;
      return 360 * 60 + (value - 270) * 15 * 60;
  }
  
  int ManualCookWindow::timeToSlider(int secs)
  {
      if (secs <= 180 * 60)

          return qCeil((qreal) secs / 60);

      if (secs <= 360 * 60)

          return 180 + qCeil((qreal) (secs - 180 * 60) / 2 / 60);
      return 270 + qCeil((qreal) (secs - 360 * 60) / 15 / 60);

  }