mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "main.h"
#include "machine.h"
#include <QSerialPortInfo>
#include <QDebug>

#include <qtmaterialtooltabs_internal.h>
#include "qtmaterialiconbutton.h"
#include "qtmaterialtoggle.h"
#include "qtmaterialcheckbox.h"
#include "OE_ui_toolbox.h"
#include "OE_ui_viewportoptions.h"
#include "OE_ui_stitchlist.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    machine(new Machine(100, 10))
{
	ui->setupUi(this);
	statusBar()->insertWidget(0, &status, 1);
	addTab();
	ui->tabWidget->removeTab(0);
    connect(machine.get(), SIGNAL(connectionChanged(bool)), this, SLOT(on_machineConnectionChanged(bool)));
    connect(machine.get(), SIGNAL(stateChanged(Machine::SlaveInfo)), this, SLOT(on_machineStateChanged(Machine::SlaveInfo)));
}

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

OE_root* MainWindow::getCurrentRoot()
{
	QWidget* widget = ui->tabWidget->currentWidget();
	return static_cast<OE_root*>(widget->property("OEroot").value<void*>());
}


void MainWindow::keyPressEvent(QKeyEvent* event)
{
	getCurrentRoot()->display->keyPressEvent(event);
}

void MainWindow::keyReleaseEvent(QKeyEvent* event)
{
	getCurrentRoot()->display->keyReleaseEvent(event);
}

void MainWindow::addTab()
{
	QWidget* newtab = new QWidget();
	newtab->setObjectName(QStringLiteral("newtab"));
	QGridLayout * newGridLayout = new QGridLayout(newtab);
	newGridLayout->setSpacing(6);
	newGridLayout->setContentsMargins(11, 11, 11, 11);
	newGridLayout->setObjectName(QStringLiteral("newGridLayout"));
	newGridLayout->setHorizontalSpacing(0);
	newGridLayout->setContentsMargins(0, 0, 0, 0);
	OE_interfaceDisplay* newOpenGLWidget = new OE_interfaceDisplay(newtab);
	newOpenGLWidget->setObjectName(QStringLiteral("newOpenGLWidget"));
	newOpenGLWidget->setMouseTracking(true);
	newOpenGLWidget->setAcceptDrops(true);
	newGridLayout->addWidget(newOpenGLWidget, 0, 0, 1, 1);

	OE_root* newRoot = new OE_root();
	newRoot->document = new OE_document();
	newRoot->interfaceDisplay = newOpenGLWidget;
	newRoot->interfaceDisplay->setDocument(newRoot->document);
	newRoot->display = newRoot->interfaceDisplay;
	newRoot->controller = new OE_controller(newRoot->display, newRoot->document);
	newRoot->controller->initNewDocument();
	newRoot->display->setController(newRoot->controller);

	//opengl window overlay layout
	QBoxLayout *openglWidgetLayout = new QHBoxLayout;
	newOpenGLWidget->setLayout(openglWidgetLayout);

	openglWidgetLayout->setSpacing(0);
    openglWidgetLayout->setMargin(0);
	openglWidgetLayout->setContentsMargins(0, 0, 0, 0);

	//left tool tab
	m_leftToolTab = new OE_ui_toolBox(this, newRoot);

	openglWidgetLayout->addWidget(m_leftToolTab);
	openglWidgetLayout->setStretch(0, 0);

	//viewport top bar (viewport options)
    m_viewportOptionBar = new OE_ui_viewportOptions(this, newRoot);

    openglWidgetLayout->addLayout(m_viewportOptionBar);
    openglWidgetLayout->setStretch(1, 0);

	openglWidgetLayout->addStretch(1);

    //selected stitches param
	QBoxLayout *stitchParamLayout = stitchParam();
	openglWidgetLayout->addLayout(stitchParamLayout);
	openglWidgetLayout->setStretch(3, 0);

	//right stitches list
	stitchesList = new OE_ui_stitchList(this, newRoot);
	stitchesList->setFixedWidth(120);
	/*stitchesList->setMargin(0);
	stitchesList->setSpacing(0);
	stitchesList->setContentsMargins(0,0,0,0);*/

	/*QtMaterialFlatButton* button = new QtMaterialFlatButton("here soon the stitches list");
	button->setFont(QFont("Roboto", 8, QFont::Medium));
	button->setUseThemeColors(true);
	button->setRole(Material::Role::Primary);
	button->setBackgroundMode(Qt::BGMode::OpaqueMode);
	button->setSizePolicy(QSizePolicy ::Expanding, QSizePolicy ::Expanding );
	button->setHaloVisible(false);

	button->setMinimumHeight(150);
	stitchesList->addWidget(button);
*/
	openglWidgetLayout->addWidget(stitchesList);
	openglWidgetLayout->setStretch(4, 0);


	int newIndex = ui->tabWidget->addTab(newtab, QString("newtab"));
	ui->tabWidget->setTabText(ui->tabWidget->indexOf(newtab), QApplication::translate("MainWindow", "Design", nullptr));

	QVariant rootPointerProperty(QVariant::fromValue(static_cast<void*>(newRoot)));
	ui->tabWidget->widget(newIndex)->setProperty("OEroot", rootPointerProperty);

	ui->tabWidget->setCurrentIndex(newIndex);
	update();
}

QBoxLayout* MainWindow::stitchParam()
{
	QVBoxLayout *topGlWindowLayout = new QVBoxLayout;
	topGlWindowLayout->setAlignment(Qt::AlignTop);

	topGlWindowLayout->addWidget(new QtMaterialToggle());
	QtMaterialCheckBox* m_checkBox = new QtMaterialCheckBox();
	m_checkBox->setText("param2");
	m_checkBox->setIconSize(QSize(5,5));
	topGlWindowLayout->addWidget(m_checkBox);
	topGlWindowLayout->setAlignment(m_checkBox, Qt::AlignCenter);
	topGlWindowLayout->addWidget(new QtMaterialFlatButton("param3"));

	return topGlWindowLayout;
}

OE_interfaceDisplay* MainWindow::getItfDisplay()
{
	QWidget* widget = ui->tabWidget->currentWidget();
	OE_root* root = static_cast<OE_root*>(widget->property("OEroot").value<void*>());
	return root->interfaceDisplay;
}

void MainWindow::sendKeyPulse(Qt::Key key, Qt::KeyboardModifiers modifiers)
{
	QKeyEvent fakeKeyPress(QKeyEvent::Type::KeyPress, key, modifiers);
	getItfDisplay()->key(&fakeKeyPress);
	QKeyEvent fakeKeyRelease(QKeyEvent::Type::KeyRelease, key, modifiers);
	getItfDisplay()->key(&fakeKeyRelease);
}

void MainWindow::on_tabWidget_tabCloseRequested(int index)
{
	// TODO some brain and warn if loss of data
	if (ui->tabWidget->count() == 1)
		addTab();
	QWidget* widget = ui->tabWidget->widget(index);
	OE_root* root = static_cast<OE_root*>(widget->property("OEroot").value<void*>());
	delete root->document;
	delete root->controller;
	delete root;
	ui->tabWidget->removeTab(index);
}

void MainWindow::on_actionNew_triggered()
{
	addTab();
}

void MainWindow::on_actionClose_triggered()
{
	on_tabWidget_tabCloseRequested(ui->tabWidget->currentIndex());
}

void MainWindow::on_actionOpen_triggered()
{ // TODO real call to a load function, not a fake key event
	sendKeyPulse(Qt::Key_O, Qt::KeyboardModifier::ControlModifier);
}

void MainWindow::on_actionSave_triggered()
{ // TODO real call to a save function, not a fake key event
	sendKeyPulse(Qt::Key_S, Qt::KeyboardModifier::ControlModifier);
}

void MainWindow::on_actionLine_triggered()
{ // TODO real call to a save function, not a fake key event
	sendKeyPulse(Qt::Key_L, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionUndo_triggered()
{
	sendKeyPulse(Qt::Key_Z, Qt::KeyboardModifier::ControlModifier);
}

void MainWindow::on_actionRedo_triggered()
{
	sendKeyPulse(Qt::Key_Z, Qt::KeyboardModifier::ControlModifier|Qt::KeyboardModifier::ShiftModifier);
}

void MainWindow::on_actionBirail_triggered()
{
	sendKeyPulse(Qt::Key_B, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionPattern1_triggered() { sendKeyPulse(Qt::Key_1, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern2_triggered() { sendKeyPulse(Qt::Key_2, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern3_triggered() { sendKeyPulse(Qt::Key_3, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern4_triggered() { sendKeyPulse(Qt::Key_4, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern5_triggered() { sendKeyPulse(Qt::Key_5, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern6_triggered() { sendKeyPulse(Qt::Key_6, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern7_triggered() { sendKeyPulse(Qt::Key_7, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern8_triggered() { sendKeyPulse(Qt::Key_8, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern9_triggered() { sendKeyPulse(Qt::Key_9, Qt::KeyboardModifier::KeypadModifier); }

void MainWindow::on_tabWidget_currentChanged(int index)
{
	if (index >= 0)
	{ // Discard previous modifiers on that widget
		QKeyEvent fakeKey(QKeyEvent::Type::KeyRelease, Qt::Key_Escape, Qt::KeyboardModifier::NoModifier);
		getItfDisplay()->key(&fakeKey);
	}
}

void MainWindow::on_actionCloseCurve_triggered()
{
	sendKeyPulse(Qt::Key_C, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionReverse_curve_R_triggered()
{
	sendKeyPulse(Qt::Key_R, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionFill_triggered()
{
	sendKeyPulse(Qt::Key_F, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionConnectToMachine_triggered(bool checked)
{
	QString msg;
	//msg += checked ? QString::fromUtf8("[ Connected  ] ") : QString::fromUtf8("[Disconnected] ");
	//msg += QString("Seq %1. Status %2. Space %3/%4. Pos (%5, %6). Point %7. tSensor %8")
	//         .arg(42,5).arg(7).arg(800,5).arg(1016,-5).arg(24,5).arg(32,-5).arg(301,4).arg(123);
	//status.setText(msg);
	if (checked)
	{
		QList<QSerialPortInfo> ports = QSerialPortInfo::availablePorts();
		if (ports.size())
		{
			machine->connectPort(ports.front().portName());
			for (const QSerialPortInfo& port : ports)
			{
				qDebug() << port.portName() << ". " << port.description() << ". " << port.manufacturer() << ". "
				         << port.vendorIdentifier() << ". " << port.productIdentifier();
			}
		}
	}
	else
	{
		machine->disconnectPort();
	}
}
void MainWindow::on_machineConnectionChanged(bool connected)
{
	if (!connected)
	{
		QString msg = status.text().replace("[ Connected  ]", "[Disconnected]");
		status.setText(msg);
	}
	ui->actionMachineRun->setEnabled(connected);
	ui->actionMachineLoad->setEnabled(connected);
	machineConnectionChanged(connected);
}
void MainWindow::on_machineStateChanged(Machine::SlaveInfo info)
{
	QString msg;
	msg = QString("[ Connected  ] Seq %1. Status %2. Space %3/%4. Pos (%5, %6). Point %7")
	        .arg(info.sequence,5)
	        .arg(info.status)
	        .arg(info.spaceSize-info.freeSpace,5).arg(info.spaceSize,-5)
	        .arg(info.posX,5).arg(info.posY,-5)
	        .arg(info.nPoint,4);
	status.setText(msg);
	printf("%s\n",msg.toStdString().c_str());
}

void MainWindow::on_actionMachineRun_triggered()
{
	machineRun();
}

void MainWindow::on_actionMachineLoad_triggered()
{
	machineLoad();
}
void MainWindow::machineRun()
{
	if (machine)
		machine->startMove();
}

void MainWindow::machineLoad()
{
	if (machine)
	{
		getCurrentRoot()->controller->sendInstPoint(machine.get());
	}
}