TrainControllerUi/src/ui/itemwidget.cpp

#include "itemwidget.h"
#include "ui_itemwidget.h"

#include <QCheckBox>
#include <QDebug>
#include <QSlider>
#include "../items/train.h"
#include "../items/turnout.h"

ItemWidget::ItemWidget(std::weak_ptr<Item> item, QWidget *parent) :
	QWidget(parent),
	item_(item),
	ui(new Ui::ItemWidget)
{
	ui->setupUi(this);

	if(auto workingItem = item_.lock())
	{
		ui->label->setText(workingItem->getName());

		connect(ui->slider, &QSlider::valueChanged, this, &ItemWidget::setValue);
		connect(ui->checkBox_f1, &QCheckBox::stateChanged, this, &ItemWidget::f1);
		connect(ui->checkBox_f2, &QCheckBox::stateChanged, this, &ItemWidget::f2);
		connect(ui->checkBox_f3, &QCheckBox::stateChanged, this, &ItemWidget::f3);
		connect(ui->checkBox_f4, &QCheckBox::stateChanged, this, &ItemWidget::f4);
		connect(ui->pushButton_reverse, &QPushButton::clicked, this, &ItemWidget::reverse);
		connect(ui->radioButton_left, &QRadioButton::clicked, this, [this]()
		{
			setValue(0);
		});
		connect(ui->radioButton_right, &QRadioButton::clicked, this, [this]()
		{
			setValue(1);
		});

		connect(workingItem.get(), &Item::valueChanged, this, &ItemWidget::moveToValue);

		Train* train = dynamic_cast<Train*>(workingItem.get());
		Turnout* turnout = dynamic_cast<Turnout*>(workingItem.get());

		if(turnout)
		{
			ui->checkBox_f1->hide();
			ui->checkBox_f2->hide();
			ui->checkBox_f3->hide();
			ui->checkBox_f4->hide();
			ui->slider->hide();
		}

		if(!train)
		{
			ui->pushButton_reverse->hide();
		}
		else
		{
			ui->radioButton_left->hide();
			ui->radioButton_right->hide();
			uint8_t functionMask = train->getFunctionMask();
			qDebug()<<"functionMask: "<<(int)functionMask;
			if(!(functionMask & (1 << 0)))
				ui->checkBox_f1->hide();
			if(!(functionMask & (1 << 1)))
				ui->checkBox_f2->hide();
			if(!(functionMask & (1 << 2)))
				ui->checkBox_f3->hide();
			if(!(functionMask & (1 << 3)))
				ui->checkBox_f4->hide();
		}
	}
	else disable();
}

void ItemWidget::deleteItem()
{
	if(auto workingItem = item_.lock())
	{
		deleteRequest(*workingItem);
	}
}

void ItemWidget::setValue(int8_t value)
{
	if(auto workingItem = item_.lock())
		workingItem->setValue(value);
	else
		disable();
}

void ItemWidget::moveToValue(int8_t value)
{
	ui->slider->blockSignals(true);
	ui->radioButton_left->blockSignals(true);
	ui->radioButton_right->blockSignals(true);

	ui->pushButton_reverse->setText(value == 0 ? "Reverse" : "Stop");
	ui->slider->setValue(value);
	ui->radioButton_left->setChecked(!value);
	ui->radioButton_right->setChecked(value);

	ui->slider->blockSignals(false);
	ui->radioButton_left->blockSignals(false);
	ui->radioButton_right->blockSignals(false);
}

void ItemWidget::f1(int value)
{
	if(auto workingItem = item_.lock())
		workingItem->setFunction(0, value == Qt::Checked);
	else disable();
}

void ItemWidget::f2(int value)
{
	if(auto workingItem = item_.lock())
		workingItem->setFunction(1, value == Qt::Checked);
	else disable();
}


void ItemWidget::f3(int value)
{
	if(auto workingItem = item_.lock())
		workingItem->setFunction(2, value == Qt::Checked);
	else disable();
}

void ItemWidget::f4(int value)
{
	if(auto workingItem = item_.lock())
		workingItem->setFunction(3, value == Qt::Checked);
	else disable();
}

void ItemWidget::reverse()
{
	if(auto workingItem = item_.lock())
	{
		Train* train = dynamic_cast<Train*>(workingItem.get());
		if(train && workingItem->getValue() == 0)
			train->reverse();
		else
		{
			setValue(!((bool)workingItem->getValue()));
		}
	}
	else disable();
}

void ItemWidget::disable()
{
	ui->checkBox_f1->setEnabled(false);
	ui->checkBox_f2->setEnabled(false);
	ui->checkBox_f3->setEnabled(false);
	ui->checkBox_f4->setEnabled(false);
	ui->label->setEnabled(false);
	ui->slider->setEnabled(false);
	ui->pushButton_reverse->setEnabled(false);
}

bool ItemWidget::controles(const ItemData& relay)
{
	if(auto workingRelay = item_.lock())
	{
		if(relay == *workingRelay)
			return  true;
		else
			return false;
	}
	return true;
}

void ItemWidget::stepUp()
{
	setValue(ui->slider->value()+1);
}

void ItemWidget::stepDown()
{
	setValue(ui->slider->value()-1);
}

void ItemWidget::setShortcuts(QKeySequence up, QKeySequence down, QKeySequence rev)
{
	shortcuts_.clear();
	shortcuts_.push_back(std::unique_ptr<QShortcut>(new  QShortcut(up, this)));
	connect(shortcuts_.back().get(), &QShortcut::activated, this, &ItemWidget::stepUp);
	shortcuts_.push_back(std::unique_ptr<QShortcut>(new  QShortcut(down, this)));
	connect(shortcuts_.back().get(), &QShortcut::activated, this, &ItemWidget::stepDown);
	shortcuts_.push_back(std::unique_ptr<QShortcut>(new  QShortcut(rev, this)));
	connect(shortcuts_.back().get(), &QShortcut::activated, this, &ItemWidget::reverse);
}

std::weak_ptr<Item> ItemWidget::getItem()
{
	return item_;
}

void ItemWidget::stateChanged(int state)
{
	qDebug()<<"widget got state "<<state;
	ui->slider->blockSignals(true);
	ui->slider->setValue(state);
	ui->slider->blockSignals(false);
}

ItemWidget::~ItemWidget()
{
	delete ui;
}