qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Application/THP/thpwidgets/thp_zoom_slider.cpp

/**
  * @RDE_HEADER@
  * A special slider for zooming
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "thp_zoom_slider.h"
#include <QLabel>
#include <QSlider>
#include <QHBoxLayout>
#include <QVBoxLayout>

namespace THP
{

ZoomSlider::ZoomSlider(QWidget *parent)
  : QWidget(parent)
  , m_InternalMin(0.1)
  , m_InternalMax(100)
  , m_LowerThreshold(1)
  , m_UpperThreshold(10)
  , m_MinRange(0)
  , m_MaxRange(280)
  , m_Slider(nullptr)
  , m_lbl(nullptr)
  , m_text(nullptr)
  , m_ZoomValue(-1)
  , m_curSliderVal(-1)
{
  setShowDescriptionLabel(true);
  setShowValueLabel(true);
  m_Slider = new QSlider(this);

  connect(m_Slider, &QSlider::valueChanged, this, &ZoomSlider::calcZoomFromSlider);
  connect(this, &ZoomSlider::valueChanged,  this, &ZoomSlider::updateLabel);

  m_Slider->setRange(m_MinRange, m_MaxRange);
  m_Slider->setSingleStep(1);
  m_Slider->setPageStep(1);

  setOrientation(Qt::Horizontal);
  //Initial calculation
  calcZoomFromSlider(m_Slider->value());

}

void ZoomSlider::setZoomValue(double zoomValue)
{
  if (qFuzzyCompare(m_ZoomValue, zoomValue))
    return;
  //ignore values outside Min/Max boundaries.
  if (zoomValue < m_InternalMin || zoomValue > m_InternalMax)
    return;
  m_ZoomValue = zoomValue;

  if (zoomValue < m_LowerThreshold)
  {
    //Range is 0..50%
    double l_Range = (m_MaxRange - m_MinRange) / 2;

    double l_ValToSet = l_Range / static_cast<double>(m_LowerThreshold - m_InternalMin) * (zoomValue - m_InternalMin);
    //qDebug() << "Value1 = "  << l_ValToSet;
    m_curSliderVal = static_cast<int>(l_ValToSet);

  }
  else if (zoomValue < m_UpperThreshold)
  {
    //Range is 50%..75%
    double l_Range = (m_MaxRange - m_MinRange) / 4;
    double l_ValToSet = l_Range / static_cast<double>(m_UpperThreshold - m_LowerThreshold) * (zoomValue - m_LowerThreshold);
    l_ValToSet += l_Range * 2;
    //qDebug() << "Value2 = "  << l_ValToSet;
    m_curSliderVal = static_cast<int>(l_ValToSet);

  }
  else
  {
    //Range is 75%..100%
    double l_Range = (m_MaxRange - m_MinRange) / 4;
    double l_ValToSet = l_Range / static_cast<double>(m_InternalMax - m_UpperThreshold)  * (zoomValue - m_UpperThreshold);
    l_ValToSet += l_Range * 3;
    //qDebug() << "Value3 = "  << l_ValToSet;
    m_curSliderVal = static_cast<int>(l_ValToSet);

  }
  m_Slider->setValue(m_curSliderVal);
  updateLabel(m_ZoomValue);
}

double ZoomSlider::getZoomValue() const
{
  return m_ZoomValue;
}

void ZoomSlider::setOrientation(Qt::Orientation a_orientation)
{
  if (!m_Slider)
    return;

  m_Slider->setOrientation(a_orientation);
  QBoxLayout *l_Layout;
  if (a_orientation == Qt::Horizontal)
  {
    m_Slider->setMinimumWidth(40);
    m_Slider->setMinimumHeight(0);
    l_Layout = new QHBoxLayout;
  }
  else
  {
    m_Slider->setMinimumWidth(0);
    m_Slider->setMinimumHeight(40);
    l_Layout = new QVBoxLayout;
  }
  l_Layout->setContentsMargins(0, 0, 0, 0);
  if (m_text)
    l_Layout->addWidget(m_text);
  if (m_Slider)
    l_Layout->addWidget(m_Slider);
  if (m_lbl)
    l_Layout->addWidget(m_lbl);
  delete layout();
  setLayout(l_Layout);
}

Qt::Orientation ZoomSlider::getOrientation() const
{
  if (m_Slider)
    return m_Slider->orientation();
  return Qt::Horizontal;
}

bool ZoomSlider::getShowDescriptionLabel() const
{
  return (m_text != nullptr);
}

void ZoomSlider::setShowDescriptionLabel(bool bVisible)
{
  if (getShowDescriptionLabel() == bVisible)
    return;
  if (bVisible)
  {
    m_text = new QLabel(this);
    m_text->setText(tr("Zoom:"));
  }
  else
  {
    delete m_text;
    m_text = nullptr;
  }
  setOrientation(getOrientation());
}

bool ZoomSlider::getShowValueLabel() const
{
  return (m_lbl != nullptr);
}

void ZoomSlider::setShowValueLabel(bool bVisible)
{
  if (getShowValueLabel() == bVisible)
    return;
  if (bVisible)
    m_lbl = new QLabel(this);
  else
  {
    delete m_lbl;
    m_lbl = nullptr;
  }
  setOrientation(getOrientation());
  updateLabel(m_ZoomValue);
}


void ZoomSlider::calcZoomFromSlider(int a_value)
{
  if (m_curSliderVal == a_value)
    return;
  m_curSliderVal = a_value;

  if (a_value < (m_MaxRange - m_MinRange) / 2)
  {
    //Range 0% - 50%
    double l_R1 = (m_MaxRange - m_MinRange) / 2;
    double l_R2 = (m_LowerThreshold - m_InternalMin);
    double l_ValToSet = l_R2 / l_R1 * a_value;
    l_ValToSet += m_InternalMin;
    //qDebug() << "Value4 = "  << l_ValToSet;
    m_ZoomValue = l_ValToSet;
  }
  else if (a_value < 3 * (m_MaxRange - m_MinRange) / 4)
  {
    //Range 50% - 75%
    double l_R1 = (m_MaxRange - m_MinRange) / 4;
    double l_R2 = (m_UpperThreshold - m_LowerThreshold);
    double l_SliderVal = a_value - (m_MaxRange - m_MinRange) / 2;
    double l_ValToSet = l_R2 / l_R1 * l_SliderVal;
    l_ValToSet += static_cast<double>(m_LowerThreshold);
    //qDebug() << "Value5 = "  << l_ValToSet;
    m_ZoomValue = l_ValToSet;
  }
  else
  {
    //Range 75% - 100%
    double l_R1 = (m_MaxRange - m_MinRange) / 4;
    double l_R2 = (m_InternalMax - m_UpperThreshold);
    double l_SliderVal = a_value - (m_MaxRange - m_MinRange) / 4 * 3;
    double l_ValToSet = l_R2 / l_R1 * l_SliderVal;

    l_ValToSet += static_cast<double>(m_UpperThreshold);
    //qDebug() << "Value6 = "  << l_ValToSet;
    m_ZoomValue = l_ValToSet;
  }
  emit valueChanged(m_ZoomValue);
}

void ZoomSlider::updateLabel(double newValue)
{
  if (!m_lbl)
    return;
  m_lbl->setText(formatValue(newValue));
}

QString ZoomSlider::formatValue(double value) const
{
  if (value < m_LowerThreshold)
    return QStringLiteral("%1x").arg(value, 4, 'f', 2);
  if (value < m_UpperThreshold)
    return QStringLiteral("%1x").arg(value, 4, 'f', 1);

  return QStringLiteral("%1x").arg(value, 4, 'f', 0);
}

} // namespace THP