/* -*- c++ -*- */
/*
 * Copyright 2015 Free Software Foundation, Inc.
 *
 * This file is part of GNU Radio
 *
 * GNU Radio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 *
 * GNU Radio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GNU Radio; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

#include <gnuradio/qtgui/timecontrolpanel.h>

TimeControlPanel::TimeControlPanel(TimeDisplayForm *form)
  : QVBoxLayout(),
    d_parent(form)
{
  // Set up the box for axes items
  d_axes_box = new QGroupBox("Axes");
  d_axes_layout = new QVBoxLayout;
  d_autoscale_check = new QCheckBox("Autoscale");
  d_grid_check = new QCheckBox("Grid");

  d_yoff_layout = new QHBoxLayout;
  d_yoff_label = new QLabel("Y Offset:");
  d_yoff_plus = new QPushButton("+");
  d_yoff_minus = new QPushButton("-");
  d_yoff_plus->setMaximumWidth(30);
  d_yoff_minus->setMaximumWidth(30);
  d_yoff_layout->addWidget(d_yoff_label);
  d_yoff_layout->addWidget(d_yoff_plus);
  d_yoff_layout->addWidget(d_yoff_minus);

  d_yrange_layout = new QHBoxLayout;
  d_yrange_label = new QLabel("Y Range:");
  d_yrange_plus = new QPushButton("+");
  d_yrange_minus = new QPushButton("-");
  d_yrange_plus->setMaximumWidth(30);
  d_yrange_minus->setMaximumWidth(30);
  d_yrange_layout->addWidget(d_yrange_label);
  d_yrange_layout->addWidget(d_yrange_plus);
  d_yrange_layout->addWidget(d_yrange_minus);

  d_xmax_layout = new QHBoxLayout;
  d_xmax_label = new QLabel("X Max:");
  d_xmax_plus = new QPushButton("+");
  d_xmax_minus = new QPushButton("-");
  d_xmax_plus->setMaximumWidth(30);
  d_xmax_minus->setMaximumWidth(30);
  d_xmax_layout->addWidget(d_xmax_label);
  d_xmax_layout->addWidget(d_xmax_plus);
  d_xmax_layout->addWidget(d_xmax_minus);


  // Set up the box for trigger items
  d_trigger_box = new QGroupBox("Trigger");
  d_trigger_layout = new QVBoxLayout;
  d_trigger_mode_combo = new QComboBox();
  d_trigger_mode_combo->addItem("Free");
  d_trigger_mode_combo->addItem("Auto");
  d_trigger_mode_combo->addItem("Normal");
  d_trigger_mode_combo->addItem("Tag");

  d_trigger_slope_combo = new QComboBox();
  d_trigger_slope_combo->addItem("Positive");
  d_trigger_slope_combo->addItem("Negative");

  d_trigger_level_layout = new QHBoxLayout;
  d_trigger_level_label = new QLabel("Level:");
  d_trigger_level_plus = new QPushButton("+");
  d_trigger_level_minus = new QPushButton("-");
  d_trigger_level_plus->setMaximumWidth(30);
  d_trigger_level_minus->setMaximumWidth(30);
  d_trigger_level_layout->addWidget(d_trigger_level_label);
  d_trigger_level_layout->addWidget(d_trigger_level_plus);
  d_trigger_level_layout->addWidget(d_trigger_level_minus);

  d_trigger_delay_layout = new QHBoxLayout;
  d_trigger_delay_label = new QLabel("Delay:");
  d_trigger_delay_plus = new QPushButton("+");
  d_trigger_delay_minus = new QPushButton("-");
  d_trigger_delay_plus->setMaximumWidth(30);
  d_trigger_delay_minus->setMaximumWidth(30);
  d_trigger_delay_layout->addWidget(d_trigger_delay_label);
  d_trigger_delay_layout->addWidget(d_trigger_delay_plus);
  d_trigger_delay_layout->addWidget(d_trigger_delay_minus);

  // Set up the box for other items
  d_extras_box = new QGroupBox("Extras");
  d_extras_layout = new QVBoxLayout;
  d_autoscale_button = new QPushButton("Autoscale");
  d_stop_button = new QPushButton("Stop");
  d_stop_button->setCheckable(true);

  // Set up the boxes into the layout
  d_axes_layout->addWidget(d_autoscale_check);
  d_axes_layout->addWidget(d_grid_check);
  d_axes_layout->addLayout(d_yoff_layout);
  d_axes_layout->addLayout(d_yrange_layout);
  d_axes_layout->addLayout(d_xmax_layout);
  d_axes_box->setLayout(d_axes_layout);

  d_trigger_layout->addWidget(d_trigger_mode_combo);
  d_trigger_layout->addWidget(d_trigger_slope_combo);
  d_trigger_layout->addLayout(d_trigger_level_layout);
  d_trigger_layout->addLayout(d_trigger_delay_layout);
  d_trigger_box->setLayout(d_trigger_layout);

  d_extras_layout->addWidget(d_autoscale_button);
  d_extras_layout->addWidget(d_stop_button);
  d_extras_box->setLayout(d_extras_layout);

  addWidget(d_axes_box);
  addWidget(d_trigger_box);
  addWidget(d_extras_box);
  addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum,
                          QSizePolicy::Expanding));

  // Connect up the control signals/slots
  connect(d_autoscale_check, SIGNAL(clicked(bool)),
	  d_parent, SLOT(autoScale(bool)));
  connect(d_grid_check, SIGNAL(clicked(bool)),
	  d_parent, SLOT(setGrid(bool)));
  connect(d_yoff_plus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyYAxisPlus(void)));
  connect(d_yoff_minus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyYAxisMinus(void)));

  connect(d_yrange_plus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyYRangePlus(void)));
  connect(d_yrange_minus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyYRangeMinus(void)));

  connect(d_xmax_plus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyXAxisPlus(void)));
  connect(d_xmax_minus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyXAxisMinus(void)));
  connect(d_trigger_mode_combo, SIGNAL(currentIndexChanged(const QString&)),
	  d_parent, SLOT(notifyTriggerMode(const QString&)));
  connect(d_trigger_slope_combo, SIGNAL(currentIndexChanged(const QString&)),
	  d_parent, SLOT(notifyTriggerSlope(const QString&)));
  connect(d_trigger_level_plus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyTriggerLevelPlus()));
  connect(d_trigger_level_minus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyTriggerLevelMinus()));
  connect(d_trigger_delay_plus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyTriggerDelayPlus()));
  connect(d_trigger_delay_minus, SIGNAL(pressed(void)),
	  d_parent, SLOT(notifyTriggerDelayMinus()));

  connect(d_autoscale_button, SIGNAL(pressed(void)),
	  d_parent, SLOT(autoScaleShot(void)));
  connect(d_stop_button, SIGNAL(pressed(void)),
          d_parent, SLOT(setStop(void)));
  connect(this, SIGNAL(signalToggleStopButton(void)),
          d_stop_button, SLOT(toggle(void)));
}

TimeControlPanel::~TimeControlPanel()
{
  removeWidget(d_axes_box);
  removeWidget(d_trigger_box);
  removeWidget(d_extras_box);
  delete d_axes_box;
  delete d_trigger_box;
  delete d_extras_box;

  // All other children of the boxes are automatically deleted.
}

void
TimeControlPanel::toggleAutoScale(bool en)
{
  d_autoscale_check->setChecked(en);
}

void
TimeControlPanel::toggleGrid(bool en)
{
  d_grid_check->setChecked(en);
}

void
TimeControlPanel::toggleTriggerMode(gr::qtgui::trigger_mode mode)
{
  d_trigger_mode_combo->setCurrentIndex(static_cast<int>(mode));
}

void
TimeControlPanel::toggleTriggerSlope(gr::qtgui::trigger_slope slope)
{
  d_trigger_slope_combo->setCurrentIndex(static_cast<int>(slope));
}

void
TimeControlPanel::toggleStopButton()
{
  emit signalToggleStopButton();
}
