DSRemote/interface.cpp

/*
***************************************************************************
*
* Author: Teunis van Beelen
*
* Copyright (C) 2015 Teunis van Beelen
*
* Email: teuniz@gmail.com
*
***************************************************************************
*
* 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
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*
***************************************************************************
*/




void UI_Mainwindow::navDialChanged(int npos)
{
  int mpr = 1;

  char str[512];

  double val, lefttime, righttime, delayrange;

  if(navDial->isSliderDown() == true)
  {
    navDial_timer->start(100);
  }
  else
  {
    navDial_timer->start(300);
  }

  if(npos > 93)
    {
      mpr = 64;
    }
    else if(npos > 86)
      {
        mpr = 32;
      }
      else if(npos > 79)
        {
          mpr = 16;
        }
        else if(npos > 72)
          {
            mpr = 8;
          }
          else if(npos > 65)
            {
              mpr = 4;
            }
            else if(npos > 58)
              {
                mpr = 2;
              }
              else if(npos > 51)
                {
                  mpr = 1;
                }
                else if(npos > 49)
                  {
                    return;
                  }
                  else if(npos > 42)
                    {
                      mpr = -1;
                    }
                    else if(npos > 35)
                      {
                        mpr = -2;
                      }
                      else if(npos > 28)
                        {
                          mpr = -4;
                        }
                        else if(npos > 21)
                          {
                            mpr = -8;
                          }
                          else if(npos > 14)
                            {
                              mpr = -16;
                            }
                            else if(npos > 7)
                              {
                                mpr = -32;
                              }
                              else
                              {
                                mpr = -64;
                              }

  if(navDialFunc == NAV_DIAL_FUNC_HOLDOFF)
  {
    adjdial_timer->start(ADJDIAL_TIMER_IVAL);

    val = get_stepsize_divide_by_1000(devparms.triggerholdoff);

    devparms.triggerholdoff += (val * mpr);

    if(devparms.triggerholdoff < 1e-7)
    {
      devparms.triggerholdoff = 1e-7;
    }

    if(devparms.triggerholdoff > 10)
    {
      devparms.triggerholdoff = 10;
    }

    strcpy(str, "Trigger holdoff: ");

    convert_to_metric_suffix(str + strlen(str), devparms.triggerholdoff, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TRIG:HOLD %e", devparms.triggerholdoff);

    tmcdev_write(device, str);
  }
  else if(devparms.timebasedelayenable)
    {
      val = get_stepsize_divide_by_1000(devparms.timebasedelayoffset);

      devparms.timebasedelayoffset += (val * mpr);

      lefttime = (7 * devparms.timebasescale) - devparms.timebaseoffset;

      righttime = (7 * devparms.timebasescale) + devparms.timebaseoffset;

      delayrange = 7 * devparms.timebasedelayscale;

      if(devparms.timebasedelayoffset < -(lefttime - delayrange))
      {
        devparms.timebasedelayoffset = -(lefttime - delayrange);
      }

      if(devparms.timebasedelayoffset > (righttime - delayrange))
      {
        devparms.timebasedelayoffset = (righttime - delayrange);
      }

      strcpy(str, "Delayed timebase position: ");

      convert_to_metric_suffix(str + strlen(str), devparms.timebasedelayoffset, 2);

      strcat(str, "s");

      statusLabel->setText(str);

      sprintf(str, ":TIM:DEL:OFFS %e", devparms.timebasedelayoffset);

      tmcdev_write(device, str);
    }
}


void UI_Mainwindow::navDialReleased()
{
  navDial->setSliderPosition(50);
}


void UI_Mainwindow::acqButtonClicked()
{
  int chn,
      chns_on=0;

  QMenu menu,
        submenuacquisition,
        submenumemdepth;

  for(chn=0; chn<MAX_CHNS; chn++)
  {
    if(devparms.chandisplay[chn])
    {
      chns_on++;
    }
  }

  submenuacquisition.setTitle("Mode");
  submenuacquisition.addAction("Normal",  this, SLOT(set_acq_normal()));
  submenuacquisition.addAction("Average", this, SLOT(set_acq_average()));
  menu.addMenu(&submenuacquisition);

  submenumemdepth.setTitle("Mem Depth");
  submenumemdepth.addAction("Auto",  this, SLOT(set_memdepth_auto()));
  if(devparms.modelserie == 6)
  {
    if(chns_on < 3)
    {
      submenumemdepth.addAction("14K",  this, SLOT(set_memdepth_14k()));
      submenumemdepth.addAction("140K", this, SLOT(set_memdepth_140k()));
      submenumemdepth.addAction("1.4M", this, SLOT(set_memdepth_1400k()));
      submenumemdepth.addAction("14M",  this, SLOT(set_memdepth_14m()));
      submenumemdepth.addAction("140M", this, SLOT(set_memdepth_140m()));
    }
    else
    {
      submenumemdepth.addAction("7K",   this, SLOT(set_memdepth_7k()));
      submenumemdepth.addAction("70K",  this, SLOT(set_memdepth_70k()));
      submenumemdepth.addAction("700K", this, SLOT(set_memdepth_700k()));
      submenumemdepth.addAction("7M",   this, SLOT(set_memdepth_7m()));
      submenumemdepth.addAction("70M",  this, SLOT(set_memdepth_70m()));
    }
  }
  else if(devparms.modelserie == 1)
    {
    if(chns_on < 2)
    {
      submenumemdepth.addAction("12K",  this, SLOT(set_memdepth_12k()));
      submenumemdepth.addAction("120K", this, SLOT(set_memdepth_120k()));
      submenumemdepth.addAction("1.2M", this, SLOT(set_memdepth_1200k()));
      submenumemdepth.addAction("12M",  this, SLOT(set_memdepth_12m()));
      submenumemdepth.addAction("24M",  this, SLOT(set_memdepth_24m()));
    }
    else if(chns_on < 3)
      {
        submenumemdepth.addAction("6K",   this, SLOT(set_memdepth_6k()));
        submenumemdepth.addAction("60K",  this, SLOT(set_memdepth_60k()));
        submenumemdepth.addAction("600K", this, SLOT(set_memdepth_600k()));
        submenumemdepth.addAction("6M",   this, SLOT(set_memdepth_6m()));
        submenumemdepth.addAction("12M",  this, SLOT(set_memdepth_12m()));
      }
      else
      {
        submenumemdepth.addAction("3K",   this, SLOT(set_memdepth_3k()));
        submenumemdepth.addAction("30K",  this, SLOT(set_memdepth_30k()));
        submenumemdepth.addAction("300K", this, SLOT(set_memdepth_300k()));
        submenumemdepth.addAction("3M",   this, SLOT(set_memdepth_3m()));
        submenumemdepth.addAction("6M",   this, SLOT(set_memdepth_6m()));
      }
    }
  menu.addMenu(&submenumemdepth);

  menu.exec(acqButton->mapToGlobal(QPoint(0,0)));
}


void UI_Mainwindow::set_memdepth_auto()
{
  statusLabel->setText("Memory depth: auto");

  tmcdev_write(device, ":ACQ:MDEP AUTO");
}


void UI_Mainwindow::set_memdepth_12k()
{
  statusLabel->setText("Memory depth: 12k");

  tmcdev_write(device, ":ACQ:MDEP 12000");
}


void UI_Mainwindow::set_memdepth_120k()
{
  statusLabel->setText("Memory depth: 120k");

  tmcdev_write(device, ":ACQ:MDEP 120000");
}


void UI_Mainwindow::set_memdepth_1200k()
{
  statusLabel->setText("Memory depth: 1.2M");

  tmcdev_write(device, ":ACQ:MDEP 1200000");
}


void UI_Mainwindow::set_memdepth_12m()
{
  statusLabel->setText("Memory depth: 12M");

  tmcdev_write(device, ":ACQ:MDEP 12000000");
}


void UI_Mainwindow::set_memdepth_24m()
{
  statusLabel->setText("Memory depth: 24M");

  tmcdev_write(device, ":ACQ:MDEP 24000000");
}


void UI_Mainwindow::set_memdepth_3k()
{
  statusLabel->setText("Memory depth: 3K");

  tmcdev_write(device, ":ACQ:MDEP 3000");
}


void UI_Mainwindow::set_memdepth_30k()
{
  statusLabel->setText("Memory depth: 30K");

  tmcdev_write(device, ":ACQ:MDEP 30000");
}


void UI_Mainwindow::set_memdepth_300k()
{
  statusLabel->setText("Memory depth: 300K");

  tmcdev_write(device, ":ACQ:MDEP 300000");
}


void UI_Mainwindow::set_memdepth_3m()
{
  statusLabel->setText("Memory depth: 3M");

  tmcdev_write(device, ":ACQ:MDEP 3000000");
}


void UI_Mainwindow::set_memdepth_6m()
{
  statusLabel->setText("Memory depth: 6M");

  tmcdev_write(device, ":ACQ:MDEP 6000000");
}


void UI_Mainwindow::set_memdepth_6k()
{
  statusLabel->setText("Memory depth: 6K");

  tmcdev_write(device, ":ACQ:MDEP 6000");
}


void UI_Mainwindow::set_memdepth_60k()
{
  statusLabel->setText("Memory depth: 60K");

  tmcdev_write(device, ":ACQ:MDEP 60000");
}


void UI_Mainwindow::set_memdepth_600k()
{
  statusLabel->setText("Memory depth: 600K");

  tmcdev_write(device, ":ACQ:MDEP 600000");
}


void UI_Mainwindow::set_memdepth_7k()
{
  statusLabel->setText("Memory depth: 7k");

  tmcdev_write(device, ":ACQ:MDEP 7000");
}


void UI_Mainwindow::set_memdepth_70k()
{
  statusLabel->setText("Memory depth: 70k");

  tmcdev_write(device, ":ACQ:MDEP 70000");
}


void UI_Mainwindow::set_memdepth_700k()
{
  statusLabel->setText("Memory depth: 700K");

  tmcdev_write(device, ":ACQ:MDEP 700000");
}


void UI_Mainwindow::set_memdepth_7m()
{
  statusLabel->setText("Memory depth: 7M");

  tmcdev_write(device, ":ACQ:MDEP 7000000");
}


void UI_Mainwindow::set_memdepth_70m()
{
  statusLabel->setText("Memory depth: 70M");

  tmcdev_write(device, ":ACQ:MDEP 70000000");
}


void UI_Mainwindow::set_memdepth_14k()
{
  statusLabel->setText("Memory depth: 14k");

  tmcdev_write(device, ":ACQ:MDEP 14000");
}


void UI_Mainwindow::set_memdepth_140k()
{
  statusLabel->setText("Memory depth: 140k");

  tmcdev_write(device, ":ACQ:MDEP 140000");
}


void UI_Mainwindow::set_memdepth_1400k()
{
  statusLabel->setText("Memory depth: 1.4M");

  tmcdev_write(device, ":ACQ:MDEP 1400000");
}


void UI_Mainwindow::set_memdepth_14m()
{
  statusLabel->setText("Memory depth: 14M");

  tmcdev_write(device, ":ACQ:MDEP 14000000");
}


void UI_Mainwindow::set_memdepth_140m()
{
  statusLabel->setText("Memory depth: 140M");

  tmcdev_write(device, ":ACQ:MDEP 140000000");
}


void UI_Mainwindow::set_acq_normal()
{
  if(devparms.acquiretype == 0)
  {
    return;
  }

  devparms.acquiretype = 0;

  statusLabel->setText("Acquire: normal");

  tmcdev_write(device, ":ACQ:TYPE NORM");
}


void UI_Mainwindow::set_acq_average()
{
  adjDialFunc = ADJ_DIAL_FUNC_ACQ_AVG;

  adjDialLabel->setText("Averages");

  adjDialLabel->setStyleSheet("background: #66FF99; font: 7pt;");

  adjdial_timer->start(ADJDIAL_TIMER_IVAL);

  if(devparms.acquiretype == 1)
  {
    return;
  }

  devparms.acquiretype = 1;

  statusLabel->setText("Acquire: average");

  tmcdev_write(device, ":ACQ:TYPE AVER");
}


void UI_Mainwindow::cursButtonClicked()
{
}


void UI_Mainwindow::saveButtonClicked()
{
  QMenu menu;

  menu.addAction("Save screen waveform",   this, SLOT(save_screen_waveform()));
  menu.addAction("Save memory waveform",   this, SLOT(save_memory_waveform()));
  menu.addAction("Save screenshot", this, SLOT(save_screenshot()));

  menu.exec(saveButton->mapToGlobal(QPoint(0,0)));
}


void UI_Mainwindow::dispButtonClicked()
{
  QMenu menu,
        submenutype,
        submenugrid,
        submenugrading;

  submenutype.setTitle("Type");
  submenutype.addAction("Vectors", this, SLOT(set_grid_type_vectors()));
  submenutype.addAction("Dots",    this, SLOT(set_grid_type_dots()));
  menu.addMenu(&submenutype);

  submenugrid.setTitle("Grid");
  submenugrid.addAction("Full", this, SLOT(set_grid_full()));
  submenugrid.addAction("Half", this, SLOT(set_grid_half()));
  submenugrid.addAction("None", this, SLOT(set_grid_none()));
  menu.addMenu(&submenugrid);

  submenugrading.setTitle("Persistence");
  submenugrading.addAction("Minimum",  this, SLOT(set_grading_min()));
  submenugrading.addAction("0.05",     this, SLOT(set_grading_005()));
  submenugrading.addAction("0.1",      this, SLOT(set_grading_01()));
  submenugrading.addAction("0.2",      this, SLOT(set_grading_02()));
  submenugrading.addAction("0.5",      this, SLOT(set_grading_05()));
  submenugrading.addAction("1",        this, SLOT(set_grading_1()));
  submenugrading.addAction("2",        this, SLOT(set_grading_2()));
  submenugrading.addAction("5",        this, SLOT(set_grading_5()));
  submenugrading.addAction("10",       this, SLOT(set_grading_10()));
  submenugrading.addAction("20",       this, SLOT(set_grading_20()));
  submenugrading.addAction("Infinite", this, SLOT(set_grading_inf()));
  menu.addMenu(&submenugrading);

  menu.exec(dispButton->mapToGlobal(QPoint(0,0)));
}


void UI_Mainwindow::set_grid_type_vectors()
{
  if(!devparms.displaytype)
  {
    return;
  }

  devparms.displaytype = 0;

  statusLabel->setText("Display type: vectors");

  tmcdev_write(device, ":DISP:TYPE VECT");
}


void UI_Mainwindow::set_grid_type_dots()
{
  if(devparms.displaytype)
  {
    return;
  }

  devparms.displaytype = 1;

  statusLabel->setText("Display type: dots");

  tmcdev_write(device, ":DISP:TYPE DOTS");
}


void UI_Mainwindow::set_grid_full()
{
  if(devparms.displaygrid == 2)
  {
    return;
  }

  devparms.displaygrid = 2;

  statusLabel->setText("Display grid: full");

  tmcdev_write(device, ":DISP:GRID FULL");
}


void UI_Mainwindow::set_grid_half()
{
  if(devparms.displaygrid == 1)
  {
    return;
  }

  devparms.displaygrid = 1;

  statusLabel->setText("Display grid: half");

  tmcdev_write(device, ":DISP:GRID HALF");
}


void UI_Mainwindow::set_grid_none()
{
  if(devparms.displaygrid == 0)
  {
    return;
  }

  devparms.displaygrid = 0;

  statusLabel->setText("Display grid: none");

  tmcdev_write(device, ":DISP:GRID NONE");
}


void UI_Mainwindow::set_grading_min()
{
  statusLabel->setText("Display grading: Minimum");

  tmcdev_write(device, ":DISP:GRAD:TIME MIN");
}


void UI_Mainwindow::set_grading_005()
{
  statusLabel->setText("Display grading: 0.05 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 0.05");
}


void UI_Mainwindow::set_grading_01()
{
  statusLabel->setText("Display grading: 0.1 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 0.1");
}


void UI_Mainwindow::set_grading_02()
{
  statusLabel->setText("Display grading: 0.2 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 0.2");
}


void UI_Mainwindow::set_grading_05()
{
  statusLabel->setText("Display grading: 0.5 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 0.5");
}


void UI_Mainwindow::set_grading_1()
{
  statusLabel->setText("Display grading: 1 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 1");
}


void UI_Mainwindow::set_grading_2()
{
  statusLabel->setText("Display grading: 2 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 2");
}


void UI_Mainwindow::set_grading_5()
{
  statusLabel->setText("Display grading: 5 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 5");
}


void UI_Mainwindow::set_grading_10()
{
  statusLabel->setText("Display grading: 10 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 10");
}


void UI_Mainwindow::set_grading_20()
{
  statusLabel->setText("Display grading: 20 Sec.");

  tmcdev_write(device, ":DISP:GRAD:TIME 20");
}


void UI_Mainwindow::set_grading_inf()
{
  statusLabel->setText("Display grading: Infinite");

  tmcdev_write(device, ":DISP:GRAD:TIME INF");
}


void UI_Mainwindow::utilButtonClicked()
{
}


void UI_Mainwindow::helpButtonClicked()
{
}


void UI_Mainwindow::show_about_dialog()
{
  UI_Aboutwindow aboutwindow;
}


void UI_Mainwindow::adjDialChanged(int new_pos)
{
  static int old_pos=0;

  int diff, dir;

  char str[512];

  if(adjDialFunc == ADJ_DIAL_FUNC_NONE)
  {
    return;
  }

  diff = new_pos - old_pos;

  if(diff < 0)
  {
    diff *= -1;
  }

  if(diff < 6)
  {
    return;
  }

  if(new_pos > old_pos)
  {
    if(diff < 12)
    {
      dir = 0;
    }
    else
    {
      dir = 1;
    }
  }
  else
  {
    if(diff < 12)
    {
      dir = 1;
    }
    else
    {
      dir = 0;
    }
  }

  if(adjDialFunc == ADJ_DIAL_FUNC_HOLDOFF)
  {
    adjdial_timer->start(ADJDIAL_TIMER_IVAL);

    if(!dir)
    {
      if(devparms.triggerholdoff >= 10)
      {
        devparms.triggerholdoff = 10;

        old_pos = new_pos;

        return;
      }

      devparms.triggerholdoff += get_stepsize_divide_by_1000(devparms.triggerholdoff);
    }
    else
    {
      if(devparms.triggerholdoff <= 1e-7)
      {
        devparms.triggerholdoff = 1e-7;

        old_pos = new_pos;

        return;
      }

      devparms.triggerholdoff -= get_stepsize_divide_by_1000(devparms.triggerholdoff);
    }

    strcpy(str, "Trigger holdoff: ");

    convert_to_metric_suffix(str + strlen(str), devparms.triggerholdoff, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TRIG:HOLD %e", devparms.triggerholdoff);

    tmcdev_write(device, str);
  }
  else if(adjDialFunc == ADJ_DIAL_FUNC_ACQ_AVG)
    {
      adjdial_timer->start(ADJDIAL_TIMER_IVAL);

      if(!dir)
      {
        if(devparms.acquireaverages >= 8192)
        {
          devparms.acquireaverages = 8192;

          old_pos = new_pos;

          return;
        }

        devparms.acquireaverages *= 2;
      }
      else
      {
        if(devparms.acquireaverages <= 2)
        {
          devparms.acquireaverages = 2;

          old_pos = new_pos;

          return;
        }

        devparms.acquireaverages /= 2;
      }

      sprintf(str, "Acquire averages: %i", devparms.acquireaverages);

      statusLabel->setText(str);

      sprintf(str, ":ACQ:AVER %i", devparms.acquireaverages);

      tmcdev_write(device, str);
    }

  old_pos = new_pos;
}


void UI_Mainwindow::trigAdjustDialChanged(int new_pos)
{
  static int old_pos=0;

  int diff, dir, chn;

  char str[512];

  if(devparms.activechannel < 0)
  {
    return;
  }

  chn = devparms.triggeredgesource;

  if((chn < 0) || (chn > 3))
  {
    return;
  }

  diff = new_pos - old_pos;

  if(diff < 0)
  {
    diff *= -1;
  }

  if(diff < 6)
  {
    return;
  }

  if(new_pos > old_pos)
  {
    if(diff < 12)
    {
      dir = 0;
    }
    else
    {
      dir = 1;
    }
  }
  else
  {
    if(diff < 12)
    {
      dir = 1;
    }
    else
    {
      dir = 0;
    }
  }

  if(dir)
  {
    if(devparms.triggeredgelevel[chn] <= (-6 * devparms.chanscale[chn]))
    {
      devparms.triggeredgelevel[chn] = -6 * devparms.chanscale[chn];

      old_pos = new_pos;

      return;
    }

    devparms.triggeredgelevel[chn] -= devparms.chanscale[chn] / 50;
  }
  else
  {
    if(devparms.triggeredgelevel[chn] >= (6 * devparms.chanscale[chn]))
    {
      devparms.triggeredgelevel[chn] = 6 * devparms.chanscale[chn];

      old_pos = new_pos;

      return;
    }

    devparms.triggeredgelevel[chn] += devparms.chanscale[chn] / 50;
  }

  strcpy(str, "Trigger level: ");

  convert_to_metric_suffix(str + strlen(str), devparms.triggeredgelevel[chn], 2);

  strcat(str, "V");

  statusLabel->setText(str);

  sprintf(str, ":TRIG:EDG:LEV %e", devparms.triggeredgelevel[chn]);

  tmcdev_write(device, str);

  old_pos = new_pos;
}


void UI_Mainwindow::horScaleDialChanged(int new_pos)
{
  static int old_pos=0;

  int diff, dir;

  char str[512];

  diff = new_pos - old_pos;

  if(diff < 0)
  {
    diff *= -1;
  }

  if(diff < 6)
  {
    return;
  }

  if(new_pos > old_pos)
  {
    if(diff < 12)
    {
      dir = 0;
    }
    else
    {
      dir = 1;
    }
  }
  else
  {
    if(diff < 12)
    {
      dir = 1;
    }
    else
    {
      dir = 0;
    }
  }

  if(devparms.timebasedelayenable)
  {
    if(dir)
    {
      if(devparms.timebasedelayscale >= devparms.timebasescale / 2)
      {
        devparms.timebasedelayscale = devparms.timebasescale / 2;

        old_pos = new_pos;

        return;
      }

      if(devparms.timebasedelayscale >= 0.1)
      {
        devparms.timebasedelayscale = 0.1;

        old_pos = new_pos;

        return;
      }
    }
    else
    {
      if(devparms.bandwidth == 1000)
      {
        if(devparms.timebasedelayscale <= 5e-10)
        {
          devparms.timebasedelayscale = 5e-10;

          old_pos = new_pos;

          return;
        }
      }
      else
      {
        if(devparms.timebasedelayscale <= 1e-9)
        {
          devparms.timebasedelayscale = 1e-9;

          old_pos = new_pos;

          return;
        }
      }
    }

    if(dir)
    {
      devparms.timebasedelayscale = round_up_step125(devparms.timebasedelayscale);
    }
    else
    {
      devparms.timebasedelayscale = round_down_step125(devparms.timebasedelayscale);
    }

    strcpy(str, "Delayed timebase: ");

    convert_to_metric_suffix(str + strlen(str), devparms.timebasedelayscale, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TIM:DEL:SCAL %e", devparms.timebasedelayscale);

    tmcdev_write(device, str);

    old_pos = new_pos;
  }
  else
  {
    if(dir)
    {
      if(devparms.timebasescale >= 10)
      {
        devparms.timebasescale = 10;

        old_pos = new_pos;

        return;
      }
    }
    else
    {
      if(devparms.bandwidth == 1000)
      {
        if(devparms.timebasescale <= 5e-10)
        {
          devparms.timebasescale = 5e-10;

          old_pos = new_pos;

          return;
        }
      }
      else
      {
        if(devparms.timebasescale <= 1e-9)
        {
          devparms.timebasescale = 1e-9;

          old_pos = new_pos;

          return;
        }
      }
    }

    if(dir)
    {
      devparms.timebasescale = round_up_step125(devparms.timebasescale);
    }
    else
    {
      devparms.timebasescale = round_down_step125(devparms.timebasescale);
    }

    strcpy(str, "Timebase: ");

    convert_to_metric_suffix(str + strlen(str), devparms.timebasescale, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TIM:SCAL %e", devparms.timebasescale);

    tmcdev_write(device, str);

    old_pos = new_pos;
  }
}


void UI_Mainwindow::horPosDialChanged(int new_pos)
{
  static int old_pos=0;

  int diff, dir;

  char str[512];

  if(devparms.activechannel < 0)
  {
    return;
  }

  diff = new_pos - old_pos;

  if(diff < 0)
  {
    diff *= -1;
  }

  if(diff < 6)
  {
    return;
  }

  if(new_pos > old_pos)
  {
    if(diff < 12)
    {
      dir = 0;
    }
    else
    {
      dir = 1;
    }
  }
  else
  {
    if(diff < 12)
    {
      dir = 1;
    }
    else
    {
      dir = 0;
    }
  }

  if(devparms.timebasedelayenable)
  {
    if(dir)
    {
      if(devparms.timebasedelayoffset >= ((7 * devparms.timebasescale) + devparms.timebaseoffset - (7 * devparms.timebasedelayscale)))
      {
        old_pos = new_pos;

        return;
      }

      devparms.timebasedelayoffset += (devparms.timebasedelayscale / 50);
    }
    else
    {
      if(devparms.timebasedelayoffset <= -((7 * devparms.timebasescale) - devparms.timebaseoffset - (7 * devparms.timebasedelayscale)))
      {
        old_pos = new_pos;

        return;
      }

      devparms.timebasedelayoffset -= (devparms.timebasedelayscale / 50);
    }

    strcpy(str, "Delayed timebase position: ");

    convert_to_metric_suffix(str + strlen(str), devparms.timebasedelayoffset, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TIM:DEL:OFFS %e", devparms.timebasedelayoffset);

    tmcdev_write(device, str);

    old_pos = new_pos;
  }
  else
  {
    if(dir)
    {
      if(devparms.timebaseoffset >= 1)
      {
        devparms.timebaseoffset = 1;

        old_pos = new_pos;

        return;
      }

      devparms.timebaseoffset += devparms.timebasescale / 50;
    }
    else
    {
      if(devparms.timebaseoffset <= -1)
      {
        devparms.timebaseoffset = -1;

        old_pos = new_pos;

        return;
      }

      devparms.timebaseoffset -= devparms.timebasescale / 50;
    }

    strcpy(str, "Horizontal position: ");

    convert_to_metric_suffix(str + strlen(str), devparms.timebaseoffset, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TIM:OFFS %e", devparms.timebaseoffset);

    tmcdev_write(device, str);

    old_pos = new_pos;
  }
}


void UI_Mainwindow::vertOffsetDialChanged(int new_pos)
{
  static int old_pos=0;

  int diff, dir, chn;

  char str[512];

  double val;

  if(devparms.activechannel < 0)
  {
    return;
  }

  chn = devparms.activechannel;

  diff = new_pos - old_pos;

  if(diff < 0)
  {
    diff *= -1;
  }

  if(diff < 6)
  {
    return;
  }

  if(new_pos > old_pos)
  {
    if(diff < 12)
    {
      dir = 0;
    }
    else
    {
      dir = 1;
    }
  }
  else
  {
    if(diff < 12)
    {
      dir = 1;
    }
    else
    {
      dir = 0;
    }
  }

  val = round_up_step125(devparms.chanscale[chn]) / 100;

  if(dir)
  {
    if(devparms.chanoffset[chn] <= -20)
    {
      devparms.chanoffset[chn] = -20;

      old_pos = new_pos;

      return;
    }

    devparms.chanoffset[chn] -= val;
  }
  else
  {
    if(devparms.chanoffset[chn] >= 20)
    {
      devparms.chanoffset[chn] = 20;

      old_pos = new_pos;

      return;
    }

    devparms.chanoffset[chn] += val;
  }

  sprintf(str, "Channel %i offset: ", chn + 1);

  convert_to_metric_suffix(str + strlen(str), devparms.chanoffset[chn], 2);

  strcat(str, "V");

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:OFFS %e", chn + 1, devparms.chanoffset[chn]);

  tmcdev_write(device, str);

  old_pos = new_pos;
}


void UI_Mainwindow::vertScaleDialChanged(int new_pos)
{
  static int old_pos=0;

  int diff, dir, chn;

  double val, ltmp;

  char str[512];

  if(devparms.activechannel < 0)
  {
    return;
  }

  chn = devparms.activechannel;

  diff = new_pos - old_pos;

  if(diff < 0)
  {
    diff *= -1;
  }

  if(diff < 6)
  {
    return;
  }

  if(new_pos > old_pos)
  {
    if(diff < 12)
    {
      dir = 0;
    }
    else
    {
      dir = 1;
    }
  }
  else
  {
    if(diff < 12)
    {
      dir = 1;
    }
    else
    {
      dir = 0;
    }
  }

  if(dir)
  {
    if(devparms.chanscale[chn] >= 20)
    {
      devparms.chanscale[chn] = 20;

      old_pos = new_pos;

      return;
    }
  }
  else
  {
    if(devparms.chanscale[chn] <= 2e-2)
    {
      devparms.chanscale[chn] = 2e-2;

      old_pos = new_pos;

      return;
    }
  }

  ltmp = devparms.chanscale[chn];

  if(dir || devparms.chanvernier[chn])
  {
    val = round_up_step125(devparms.chanscale[chn]);
  }
  else
  {
    val = round_down_step125(devparms.chanscale[chn]);
  }

  if(devparms.chanvernier[chn])
  {
    val /= 100;

    if(dir)
    {
      devparms.chanscale[chn] += val;
    }
    else
    {
      devparms.chanscale[chn] -= val;
    }
  }
  else
  {
    devparms.chanscale[chn] = val;
  }

  ltmp /= val;

  devparms.chanoffset[chn] /= ltmp;

  sprintf(str, "Channel %i scale: ", chn + 1);

  convert_to_metric_suffix(str + strlen(str), devparms.chanscale[chn], 2);

  strcat(str, "V");

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:SCAL %e", chn + 1, devparms.chanscale[chn]);

  tmcdev_write(device, str);

  old_pos = new_pos;
}


void UI_Mainwindow::vertScaleDialClicked(QPoint)
{
  int chn;

  char str[512];

  if(devparms.activechannel < 0)
  {
    return;
  }

  chn = devparms.activechannel;

  if(devparms.chanvernier[chn])
  {
    devparms.chanvernier[chn] = 0;

    sprintf(str, "Channel %i vernier: off", chn + 1);

    statusLabel->setText(str);

    sprintf(str, ":CHAN%i:VERN 0", chn + 1);

    tmcdev_write(device, str);
  }
  else
  {
    devparms.chanvernier[chn] = 1;

    sprintf(str, "Channel %i vernier: on", chn + 1);

    statusLabel->setText(str);

    sprintf(str, ":CHAN%i:VERN 1", chn + 1);

    tmcdev_write(device, str);
  }
}


void UI_Mainwindow::ch1ButtonClicked()
{
  if(devparms.chandisplay[0])
  {
    if(devparms.activechannel == 0)
    {
      devparms.chandisplay[0] = 0;

      statusLabel->setText("Channel 1 off");

      tmcdev_write(device, ":CHAN1:DISP 0");

      ch1Button->setStyleSheet(def_stylesh);

      devparms.activechannel = -1;

      for(int i=0; i<MAX_CHNS; i++)
      {
        if(devparms.chandisplay[i])
        {
          devparms.activechannel = i;

          break;
        }
      }
    }
    else
    {
      devparms.activechannel = 0;
    }
  }
  else
  {
    devparms.chandisplay[0] = 1;

    statusLabel->setText("Channel 1 on");

    tmcdev_write(device, ":CHAN1:DISP 1");

    ch1Button->setStyleSheet("background: #FFFF33;");

    devparms.activechannel = 0;
  }
}


void UI_Mainwindow::ch2ButtonClicked()
{
  if(devparms.chandisplay[1])
  {
    if(devparms.activechannel == 1)
    {
      devparms.chandisplay[1] = 0;

      statusLabel->setText("Channel 2 off");

      tmcdev_write(device, ":CHAN2:DISP 0");

      ch2Button->setStyleSheet(def_stylesh);

      devparms.activechannel = -1;

      for(int i=0; i<MAX_CHNS; i++)
      {
        if(devparms.chandisplay[i])
        {
          devparms.activechannel = i;

          break;
        }
      }
    }
    else
    {
      devparms.activechannel = 1;
    }
  }
  else
  {
    devparms.chandisplay[1] = 1;

    statusLabel->setText("Channel 2 on");

    tmcdev_write(device, ":CHAN2:DISP 1");

    ch2Button->setStyleSheet("background: #33FFFF;");

    devparms.activechannel = 1;
  }
}


void UI_Mainwindow::ch3ButtonClicked()
{
  if(devparms.chandisplay[2])
  {
    if(devparms.activechannel == 2)
    {
      devparms.chandisplay[2] = 0;

      statusLabel->setText("Channel 3 off");

      tmcdev_write(device, ":CHAN3:DISP 0");

      ch3Button->setStyleSheet(def_stylesh);

      devparms.activechannel = -1;

      for(int i=0; i<MAX_CHNS; i++)
      {
        if(devparms.chandisplay[i])
        {
          devparms.activechannel = i;

          break;
        }
      }
    }
    else
    {
      devparms.activechannel = 2;
    }
  }
  else
  {
    devparms.chandisplay[2] = 1;

    statusLabel->setText("Channel 3 on");

    tmcdev_write(device, ":CHAN3:DISP 1");

    ch3Button->setStyleSheet("background: #FF33FF;");

    devparms.activechannel = 2;
  }
}


void UI_Mainwindow::ch4ButtonClicked()
{
  if(devparms.chandisplay[3])
  {
    if(devparms.activechannel == 3)
    {
      devparms.chandisplay[3] = 0;

      statusLabel->setText("Channel 4 off");

      tmcdev_write(device, ":CHAN4:DISP 0");

      ch4Button->setStyleSheet(def_stylesh);

      devparms.activechannel = -1;

      for(int i=0; i<MAX_CHNS; i++)
      {
        if(devparms.chandisplay[i])
        {
          devparms.activechannel = i;

          break;
        }
      }
    }
    else
    {
      devparms.activechannel = 3;
    }
  }
  else
  {
    devparms.chandisplay[3] = 1;

    statusLabel->setText("Channel 4 on");

    tmcdev_write(device, ":CHAN4:DISP 1");

    ch4Button->setStyleSheet("background: #0066CC;");

    devparms.activechannel = 3;
  }
}


void UI_Mainwindow::chan_menu()
{
  QMenu menu,
        submenubwl,
        submenucoupling,
        submenuinvert;

  if((devparms.activechannel < 0) || (devparms.activechannel > MAX_CHNS))
  {
    return;
  }

  submenucoupling.setTitle("Coupling");
  submenucoupling.addAction("AC",  this, SLOT(chan_coupling_ac()));
  submenucoupling.addAction("DC",  this, SLOT(chan_coupling_dc()));
  submenucoupling.addAction("GND", this, SLOT(chan_coupling_gnd()));
  menu.addMenu(&submenucoupling);

  submenubwl.setTitle("BWL");
  submenubwl.addAction("Off",    this, SLOT(chan_bwl_off()));
  submenubwl.addAction("20MHz",  this, SLOT(chan_bwl_20()));
  submenubwl.addAction("250MHz", this, SLOT(chan_bwl_250()));
  menu.addMenu(&submenubwl);

  submenuinvert.setTitle("Invert");
  submenuinvert.addAction("On",  this, SLOT(chan_invert_on()));
  submenuinvert.addAction("Off", this, SLOT(chan_invert_off()));
  menu.addMenu(&submenuinvert);

  menu.exec(chanMenuButton->mapToGlobal(QPoint(0,0)));
}


void UI_Mainwindow::chan_coupling_ac()
{
  char str[128];

  devparms.chancoupling[devparms.activechannel] = 2;

  sprintf(str, "Channel %i coupling: AC", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:COUP AC", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::chan_coupling_dc()
{
  char str[128];

  devparms.chancoupling[devparms.activechannel] = 1;

  sprintf(str, "Channel %i coupling: DC", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:COUP DC", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::chan_coupling_gnd()
{
  char str[128];

  devparms.chancoupling[devparms.activechannel] = 0;

  sprintf(str, "Channel %i coupling: GND", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:COUP GND", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::chan_bwl_off()
{
  char str[128];

  devparms.chanbwlimit[devparms.activechannel] = 0;

  sprintf(str, "Channel %i bandwidth limit: Off", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:BWL OFF", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::chan_bwl_20()
{
  char str[128];

  devparms.chanbwlimit[devparms.activechannel] = 20;

  sprintf(str, "Channel %i bandwidth limit: 20MHz", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:BWL 20M", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::chan_bwl_250()
{
  char str[128];

  devparms.chanbwlimit[devparms.activechannel] = 250;

  sprintf(str, "Channel %i bandwidth limit: 250MHz", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:BWL 250M", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::chan_invert_on()
{
  char str[128];

  if(!devparms.chaninvert[devparms.activechannel])
  {
    devparms.triggeredgelevel[devparms.activechannel] *= -1;
  }

  devparms.chaninvert[devparms.activechannel] = 1;

  sprintf(str, "Channel %i inverted: On", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:INV 1", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::chan_invert_off()
{
  char str[128];

  if(devparms.chaninvert[devparms.activechannel])
  {
    devparms.triggeredgelevel[devparms.activechannel] *= -1;
  }

  devparms.chaninvert[devparms.activechannel] = 0;

  sprintf(str, "Channel %i inverted: Off", devparms.activechannel + 1);

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:INV 0", devparms.activechannel + 1);

  tmcdev_write(device, str);
}


void UI_Mainwindow::vertOffsetDialClicked(QPoint)
{
//   QMenu menu;
//
//   menu.addAction("Zero", this, SLOT(vertical_position_zero()));
//
//   menu.exec(vertOffsetDial->mapToGlobal(QPoint(0,0)));
  int chn;

  char str[512];

  if(devparms.activechannel < 0)
  {
    return;
  }

  chn = devparms.activechannel;

  devparms.chanoffset[chn] = 0;

  sprintf(str, "Channel %i offset: ", chn + 1);

  convert_to_metric_suffix(str + strlen(str), devparms.chanoffset[chn], 2);

  strcat(str, "V");

  statusLabel->setText(str);

  sprintf(str, ":CHAN%i:OFFS %e", chn + 1, devparms.chanoffset[chn]);

  tmcdev_write(device, str);
}


void UI_Mainwindow::clearButtonClicked()
{
  statusLabel->setText("Display cleared");

  tmcdev_write(device, ":DISP:CLE");
}


void UI_Mainwindow::autoButtonClicked()
{
  statusLabel->setText("Auto settings");

  tmcdev_write(device, ":AUT");
}


void UI_Mainwindow::runButtonClicked()
{
  if(devparms.triggerstatus == 5)
  {
    statusLabel->setText("Trigger: run");

    tmcdev_write(device, ":RUN");
  }
  else
  {
    statusLabel->setText("Trigger: stop");

    tmcdev_write(device, ":STOP");
  }
}


void UI_Mainwindow::singleButtonClicked()
{
  statusLabel->setText("Trigger: single");

  tmcdev_write(device, ":SING");
}


void UI_Mainwindow::adjustDialClicked(QPoint)
{
  if(adjDialFunc == ADJ_DIAL_FUNC_HOLDOFF)
  {
    devparms.triggerholdoff = 1e-7;

    statusLabel->setText("Holdoff: 100ns");

    tmcdev_write(device, ":TRIG:HOLD 1e-7");
  }
}


void UI_Mainwindow::horMenuButtonClicked()
{
  QMenu menu,
        submenudelayed;

  submenudelayed.setTitle("Delayed");
  submenudelayed.addAction("On",  this, SLOT(horizontal_delayed_on()));
  submenudelayed.addAction("Off", this, SLOT(horizontal_delayed_off()));
  menu.addMenu(&submenudelayed);

  menu.exec(horMenuButton->mapToGlobal(QPoint(0,0)));
}


void UI_Mainwindow::horizontal_delayed_on()
{
  if(devparms.timebasedelayenable)
  {
    return;
  }

  devparms.timebasedelayenable = 1;

  statusLabel->setText("Delayed timebase enabled");

  tmcdev_write(device, ":TIM:DEL:ENAB 1");

  devparms.timebasedelayoffset = devparms.timebaseoffset;
}


void UI_Mainwindow::horizontal_delayed_off()
{
  if(!devparms.timebasedelayenable)
  {
    return;
  }

  devparms.timebasedelayenable = 0;

  statusLabel->setText("Delayed timebase disabled");

  tmcdev_write(device, ":TIM:DEL:ENAB 0");
}


void UI_Mainwindow::horizontal_delayed_toggle()
{
  if(devparms.timebasedelayenable)
  {
    devparms.timebasedelayenable = 0;

    statusLabel->setText("Delayed timebase disabled");

    tmcdev_write(device, ":TIM:DEL:ENAB 0");
  }
  else
  {
    stat_timer->stop();

    scrn_timer->stop();

    devparms.timebasedelayenable = 1;

    statusLabel->setText("Delayed timebase enabled");

    tmcdev_write(device, ":TIM:DEL:ENAB 1");

    tmcdev_write(device, ":TIM:DEL:OFFS?");

    tmcdev_read(device);

    devparms.timebasedelayoffset = atof(device->buf);

    tmcdev_write(device, ":TIM:DEL:SCAL?");

    tmcdev_read(device);

    devparms.timebasedelayscale = atof(device->buf);

    stat_timer->start(devparms.status_timer_ival);

    scrn_timer->start(devparms.screen_timer_ival);
  }
}


void UI_Mainwindow::horPosDialClicked(QPoint)
{
  char str[512];

  if(devparms.timebasedelayenable)
  {
    devparms.timebasedelayoffset = devparms.timebaseoffset;

    strcpy(str, "Delayed timebase position: ");

    convert_to_metric_suffix(str + strlen(str), devparms.timebasedelayoffset, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TIM:DEL:OFFS %e", devparms.timebasedelayoffset);

    tmcdev_write(device, str);
  }
  else
  {
    devparms.timebaseoffset = 0;

    strcpy(str, "Horizontal position: ");

    convert_to_metric_suffix(str + strlen(str), devparms.timebaseoffset, 2);

    strcat(str, "s");

    statusLabel->setText(str);

    sprintf(str, ":TIM:OFFS %e", devparms.timebaseoffset);

    tmcdev_write(device, str);
  }
}


void UI_Mainwindow::horScaleDialClicked(QPoint)
{
  horizontal_delayed_toggle();
}


void UI_Mainwindow::measureButtonClicked()
{
  QMenu menu,
        submenucounter;

  submenucounter.setTitle("Counter");
  submenucounter.addAction("OFF", this, SLOT(counter_off()));
  submenucounter.addAction("CH1", this, SLOT(counter_ch1()));
  if(devparms.channel_cnt > 1)
  {
    submenucounter.addAction("CH2", this, SLOT(counter_ch2()));
  }
  if(devparms.channel_cnt > 2)
  {
    submenucounter.addAction("CH3", this, SLOT(counter_ch3()));
  }
  if(devparms.channel_cnt > 3)
  {
    submenucounter.addAction("CH4", this, SLOT(counter_ch4()));
  }

  menu.addMenu(&submenucounter);

  menu.exec(measureButton->mapToGlobal(QPoint(0,0)));
}


void UI_Mainwindow::counter_off()
{
  devparms.countersrc = 0;

  statusLabel->setText("Freq. counter off");

  tmcdev_write(device, ":MEAS:COUN:SOUR OFF");
}


void UI_Mainwindow::counter_ch1()
{
  devparms.countersrc = 1;

  statusLabel->setText("Freq. counter channel 1");

  tmcdev_write(device, ":MEAS:COUN:SOUR CHAN1");
}


void UI_Mainwindow::counter_ch2()
{
  devparms.countersrc = 2;

  statusLabel->setText("Freq. counter channel 2");

  tmcdev_write(device, ":MEAS:COUN:SOUR CHAN2");
}


void UI_Mainwindow::counter_ch3()
{
  devparms.countersrc = 3;

  statusLabel->setText("Freq. counter channel 3");

  tmcdev_write(device, ":MEAS:COUN:SOUR CHAN3");
}


void UI_Mainwindow::counter_ch4()
{
  devparms.countersrc = 4;

  statusLabel->setText("Freq. counter channel 4");

  tmcdev_write(device, ":MEAS:COUN:SOUR CHAN4");
}


void UI_Mainwindow::trigModeButtonClicked()
{
  devparms.triggersweep++;

  devparms.triggersweep %= 3;

  switch(devparms.triggersweep)
  {
    case 0: trigModeAutoLed->setValue(true);
            trigModeSingLed->setValue(false);
            statusLabel->setText("Trigger auto");
            tmcdev_write(device, ":TRIG:SWE AUTO");
            break;
    case 1: trigModeNormLed->setValue(true);
            trigModeAutoLed->setValue(false);
            statusLabel->setText("Trigger norm");
            tmcdev_write(device, ":TRIG:SWE NORM");
            break;
    case 2: trigModeSingLed->setValue(true);
            trigModeNormLed->setValue(false);
            statusLabel->setText("Trigger single");
            tmcdev_write(device, ":TRIG:SWE SING");
            break;
  }
}


void UI_Mainwindow::trigMenuButtonClicked()
{
  QMenu menu,
        submenusource,
        submenuslope,
        submenucoupling,
        submenusetting;

  submenusource.setTitle("Source");
  submenusource.addAction("CH1", this, SLOT(trigger_source_ch1()));
  if(devparms.channel_cnt > 1)
  {
    submenusource.addAction("CH2", this, SLOT(trigger_source_ch2()));
  }
  if(devparms.channel_cnt > 2)
  {
    submenusource.addAction("CH3", this, SLOT(trigger_source_ch3()));
  }
  if(devparms.channel_cnt > 3)
  {
    submenusource.addAction("CH4", this, SLOT(trigger_source_ch4()));
  }
  submenusource.addAction("EXT", this, SLOT(trigger_source_ext()));
  submenusource.addAction("EXT/ 5", this, SLOT(trigger_source_ext5()));
  submenusource.addAction("AC Line", this, SLOT(trigger_source_acl()));
  menu.addMenu(&submenusource);

  submenucoupling.setTitle("Coupling");
  submenucoupling.addAction("DC", this, SLOT(trigger_coupling_dc()));
  submenucoupling.addAction("AC", this, SLOT(trigger_coupling_ac()));
  submenucoupling.addAction("LF reject", this, SLOT(trigger_coupling_lfreject()));
  submenucoupling.addAction("HF reject", this, SLOT(trigger_coupling_hfreject()));
  menu.addMenu(&submenucoupling);

  submenuslope.setTitle("Slope");
  submenuslope.addAction("Positive", this, SLOT(trigger_slope_pos()));
  submenuslope.addAction("Negative", this, SLOT(trigger_slope_neg()));
  submenuslope.addAction("Rise/Fal", this, SLOT(trigger_slope_rfal()));
  menu.addMenu(&submenuslope);

  submenusetting.setTitle("Setting");
  submenusetting.addAction("Holdoff", this, SLOT(trigger_setting_holdoff()));
  menu.addMenu(&submenusetting);

  menu.exec(trigMenuButton->mapToGlobal(QPoint(0,0)));
}


void UI_Mainwindow::trigger_source_ch1()
{
  devparms.triggeredgesource = 0;

  statusLabel->setText("Trigger source channel 1");

  tmcdev_write(device, ":TRIG:EDG:SOUR CHAN1");
}


void UI_Mainwindow::trigger_source_ch2()
{
  devparms.triggeredgesource = 1;

  statusLabel->setText("Trigger source channel 2");

  tmcdev_write(device, ":TRIG:EDG:SOUR CHAN2");
}


void UI_Mainwindow::trigger_source_ch3()
{
  devparms.triggeredgesource = 2;

  statusLabel->setText("Trigger source channel 3");

  tmcdev_write(device, ":TRIG:EDG:SOUR CHAN3");
}


void UI_Mainwindow::trigger_source_ch4()
{
  devparms.triggeredgesource = 3;

  statusLabel->setText("Trigger source channel 4");

  tmcdev_write(device, ":TRIG:EDG:SOUR CHAN4");
}


void UI_Mainwindow::trigger_source_ext()
{
  devparms.triggeredgesource = 4;

  statusLabel->setText("Trigger source extern");

  tmcdev_write(device, ":TRIG:EDG:SOUR EXT");
}


void UI_Mainwindow::trigger_source_ext5()
{
  devparms.triggeredgesource = 5;

  statusLabel->setText("Trigger source extern 5");

  tmcdev_write(device, ":TRIG:EDG:SOUR EXT5");
}


void UI_Mainwindow::trigger_source_acl()
{
  devparms.triggeredgesource = 6;

  statusLabel->setText("Trigger source AC powerline");

  tmcdev_write(device, ":TRIG:EDG:SOUR ACL");
}


void UI_Mainwindow::trigger_coupling_ac()
{
  devparms.triggercoupling = 0;

  statusLabel->setText("Trigger coupling AC");

  tmcdev_write(device, ":TRIG:COUP AC");
}


void UI_Mainwindow::trigger_coupling_dc()
{
  devparms.triggercoupling = 1;

  statusLabel->setText("Trigger coupling DC");

  tmcdev_write(device, ":TRIG:COUP DC");
}


void UI_Mainwindow::trigger_coupling_lfreject()
{
  devparms.triggercoupling = 2;

  statusLabel->setText("Trigger LF reject");

  tmcdev_write(device, ":TRIG:COUP LFR");
}


void UI_Mainwindow::trigger_coupling_hfreject()
{
  devparms.triggercoupling = 3;

  statusLabel->setText("Trigger HF reject");

  tmcdev_write(device, ":TRIG:COUP HFR");
}


void UI_Mainwindow::trigger_slope_pos()
{
  devparms.triggeredgeslope = 0;

  statusLabel->setText("Trigger edge positive");

  tmcdev_write(device, ":TRIG:EDG:SLOP POS");
}


void UI_Mainwindow::trigger_slope_neg()
{
  devparms.triggeredgeslope = 1;

  statusLabel->setText("Trigger edge negative");

  tmcdev_write(device, ":TRIG:EDG:SLOP NEG");
}


void UI_Mainwindow::trigger_slope_rfal()
{
  devparms.triggeredgeslope = 2;

  statusLabel->setText("Trigger edge positive /negative");

  tmcdev_write(device, ":TRIG:EDG:SLOP RFAL");
}


void UI_Mainwindow::trigger_setting_holdoff()
{
  navDialFunc = NAV_DIAL_FUNC_HOLDOFF;

  adjDialFunc = ADJ_DIAL_FUNC_HOLDOFF;

  adjDialLabel->setText("Holdoff");

  adjDialLabel->setStyleSheet("background: #66FF99; font: 7pt;");

  adjdial_timer->start(ADJDIAL_TIMER_IVAL);
}


void UI_Mainwindow::trigForceButtonClicked()
{
  statusLabel->setText("Trigger force");

  tmcdev_write(device, ":TFOR");
}


void UI_Mainwindow::trig50pctButtonClicked()
{
  statusLabel->setText("Trigger 50%");

  tmcdev_write(device, ":TLHA");

  tmcdev_write(device, ":TRIG:EDG:LEV?");

  tmcdev_read(device);

  devparms.triggeredgelevel[devparms.triggeredgesource] = atof(device->buf);

  waveForm->setTrigLineVisible();
}


void UI_Mainwindow::trigAdjustDialClicked(QPoint)
{
  char str[512];

  devparms.triggeredgelevel[devparms.triggeredgesource] = 0;

  strcpy(str, "Trigger level: ");

  convert_to_metric_suffix(str + strlen(str), devparms.triggeredgelevel[devparms.triggeredgesource], 2);

  strcat(str, "V");

  statusLabel->setText(str);

  sprintf(str, ":TRIG:EDG:LEV %e", devparms.triggeredgelevel[devparms.triggeredgesource]);

  tmcdev_write(device, str);
}