/Misc Projects/PcMarlinInterface/MacroController.cpp |
---|
File deleted |
/Misc Projects/PcMarlinInterface/SerialController.cpp |
---|
File deleted |
/Misc Projects/PcMarlinInterface/SerialController.h |
---|
File deleted |
/Misc Projects/PcMarlinInterface/MacroController.h |
---|
File deleted |
/Misc Projects/PcMarlinInterface/MacroWidget.cpp |
---|
0,0 → 1,401 |
#include "MacroWidget.h" |
MacroWidget::MacroWidget(QWidget *parent) : QWidget(parent) |
{ |
sigmapTransmit = new QSignalMapper(); |
sigmapKeybind = new QSignalMapper(); |
btnExport = new QPushButton("&Export"); |
btnImport = new QPushButton("&Import"); |
btnAddMacro = new QPushButton("&Add"); |
btnRemoveMacro = new QPushButton("&Remove"); |
btnClear = new QPushButton("&Clear"); |
currKeyBindInfo = QPair<QPushButton*,int>(NULL, 0); |
mainLayout = new QGridLayout(); |
macroCount = 0; |
connected = false; |
lastKnownFilePath = "."; |
ioLayout = new QHBoxLayout(); |
ioLayout->addWidget(btnAddMacro); |
ioLayout->addWidget(btnRemoveMacro); |
ioLayout->addWidget(btnClear); |
ioLayout->addWidget(btnExport); |
ioLayout->addWidget(btnImport); |
ioLayout->addStretch(); |
mainLayout->addLayout(ioLayout, 0, 0, 1, 2); |
for (int i = 0; i < MACRO_DEFAULT_COUNT; i++) { |
Macro_AddEntry(); |
} |
setLayout(mainLayout); |
connect(btnAddMacro, SIGNAL(clicked()), this, SLOT(Macro_AddEntry())); |
connect(btnRemoveMacro, SIGNAL(clicked()), this, SLOT(Macro_RemoveEntry())); |
connect(btnClear, SIGNAL(clicked()), this, SLOT(Macro_Clear())); |
connect(btnExport, SIGNAL(clicked()), this, SLOT(Macro_WriteToFile())); |
connect(btnImport, SIGNAL(clicked()), this, SLOT(Macro_ReadFromFile())); |
connect(sigmapTransmit, SIGNAL(mapped(QWidget*)), this, SLOT(Macro_InitTransmit(QWidget*))); |
connect(sigmapKeybind, SIGNAL(mapped(int)), this, SLOT(Macro_KeybindPrompt(int))); |
// Register global event process for keyboard shortcut handling |
qApp->installEventFilter(this); |
} |
MacroWidget::~MacroWidget() |
{ |
} |
QSize MacroWidget::sizeHint() const |
{ |
return this->minimumSizeHint(); |
} |
void MacroWidget::Macro_EnableTransmit() |
{ |
connected = true; |
for (int i = 0; i < macroBtnSendList.size(); i++) { |
macroBtnSendList[i]->setEnabled(true); |
} |
} |
void MacroWidget::Macro_DisableTransmit() |
{ |
connected = false; |
for (int i = 0; i < macroBtnSendList.size(); i++) { |
macroBtnSendList[i]->setEnabled(false); |
} |
} |
void MacroWidget::Macro_InitTransmit(QWidget *t) |
{ |
if (connected) { |
QTextEdit *text = qobject_cast<QTextEdit*>(t); |
emit Macro_TransmitText(text->toPlainText().toUtf8()); |
} |
} |
void MacroWidget::Macro_KeybindPrompt(int id) |
{ |
QPushButton *btn = qobject_cast<QPushButton*>(sigmapKeybind->mapping(id)); |
// Check to make sure we arn't processing another key first |
if (currKeyBindInfo.first != NULL) { |
currKeyBindInfo.first->setText("Hotkey: None"); |
currKeyBindInfo.first->setDown(false); |
currKeyBindInfo.first->removeEventFilter(this); |
} |
// Mark and save button as waiting for key sequence |
btn->setDown(true); |
btn->setText("Waiting for Key.."); |
currKeyBindInfo = QPair<QPushButton*,int>(btn, id); |
// Remove current keybinding for this macro |
int index = registeredKeyMacroIDs.indexOf(id); |
if (index >= 0) { |
registeredKeySequences.removeAt(index); |
registeredKeyMacroIDs.removeAt(index); |
} |
// Inspect all following keyboard events |
btn->installEventFilter(this); |
} |
void MacroWidget::Macro_AddEntry() |
{ |
macroCount++; |
// Create new layout/widgets |
QLineEdit *lineEdit = new QLineEdit(QString("Macro %1").arg(macroCount)); |
lineEdit->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed); |
lineEdit->setMinimumWidth(100); |
lineEdit->setAlignment(Qt::AlignCenter); |
macroNameList.append(lineEdit); |
QTextEdit *textEdit = new QTextEdit(); |
textEdit->setMinimumHeight(50); |
textEdit->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); |
textEdit->setWordWrapMode(QTextOption::NoWrap); |
textEdit->setFont(QFont("Consolas", 8)); |
textEdit->setAcceptRichText(false); |
textEdit->setTabChangesFocus(true); |
macroValueList.append(textEdit); |
QPushButton *keyButton = new QPushButton("Hotkey: None"); |
keyButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed); |
macroBtnKeyList.append(keyButton); |
QPushButton *pushButton = new QPushButton("Send Macro"); |
pushButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); |
pushButton->setEnabled(connected); |
macroBtnSendList.append(pushButton); |
QVBoxLayout *tmpLayout = new QVBoxLayout(); |
tmpLayout->addWidget(lineEdit); |
tmpLayout->addWidget(keyButton); |
tmpLayout->addWidget(pushButton); |
// Add layout/widgets to main layout |
mainLayout->addLayout(tmpLayout, macroCount, 0); |
mainLayout->addWidget(textEdit, macroCount, 1); |
mainLayout->setColumnStretch(1, 1); |
// Associate KeyButton with its corresponding ID |
sigmapKeybind->setMapping(keyButton, macroCount-1); |
connect(keyButton, SIGNAL(clicked()), sigmapKeybind, SLOT(map())); |
// Associate PushButton with its corresponding TextEdit |
sigmapTransmit->setMapping(pushButton, textEdit); |
connect(pushButton, SIGNAL(clicked()), sigmapTransmit, SLOT(map())); |
QLayoutItem *item = mainLayout->itemAtPosition(1, 1); |
int height = item->widget()->height() + mainLayout->verticalSpacing(); |
QDockWidget *parent = qobject_cast<QDockWidget*>(this->parent()); |
if (parent->isFloating()) |
parent->resize(parent->width(), parent->height() + height); |
btnRemoveMacro->setEnabled(true); |
} |
void MacroWidget::Macro_RemoveEntry() |
{ |
// Remove and delete layout/widgets at last macro slot |
QLayoutItem *item = mainLayout->itemAtPosition(macroCount, 0); |
while(!item->isEmpty()) |
delete item->layout()->takeAt(0)->widget(); |
delete item; |
item = mainLayout->itemAtPosition(macroCount, 1); |
delete item->widget(); |
item = mainLayout->itemAtPosition(1, 1); |
int height = item->widget()->height() + mainLayout->verticalSpacing(); |
// Unmap and remove widgets from lists |
QPushButton *pushButton = macroBtnSendList.back(); |
sigmapTransmit->removeMappings(pushButton); |
QPushButton *keyButton = macroBtnKeyList.back(); |
sigmapKeybind->removeMappings(keyButton); |
macroNameList.pop_back(); |
macroValueList.pop_back(); |
macroBtnSendList.pop_back(); |
macroBtnKeyList.pop_back(); |
int index = registeredKeyMacroIDs.indexOf(macroCount-1); |
if (index >= 0) { |
registeredKeySequences.removeAt(index); |
registeredKeyMacroIDs.removeAt(index); |
} |
macroCount--; |
QDockWidget *parent = qobject_cast<QDockWidget*>(this->parent()); |
if (parent->isFloating()) |
parent->resize(parent->width(), parent->height() - height); |
if (macroCount == 1) |
btnRemoveMacro->setEnabled(false); |
} |
void MacroWidget::Macro_Clear() |
{ |
for (int i = 0; i < macroCount; i++) { |
macroNameList[i]->setText(QString("Macro %1").arg(i+1)); |
macroValueList[i]->clear(); |
macroBtnKeyList[i]->setText("Hotkey: None"); |
} |
registeredKeyMacroIDs.clear(); |
registeredKeySequences.clear(); |
} |
void MacroWidget::Macro_WriteToFile() |
{ |
QString file = QFileDialog::getSaveFileName(this, "Settings XML File", lastKnownFilePath, "XML File (*.xml)"); |
QCoreApplication::processEvents(); // Wait for dialog to close |
if (file.size() == 0) return; |
// If file was selected, save directory for next time |
QFileInfo fileInfo = QFileInfo(file); |
lastKnownFilePath = fileInfo.absolutePath(); |
if (file.size() != 0) |
QFile::remove(file); |
QFile inputFile(file); |
if (!inputFile.open(QIODevice::ReadWrite | QIODevice::Text)) return; |
QXmlStreamWriter stream(&inputFile); |
stream.setAutoFormatting(true); |
stream.writeStartDocument(); |
stream.writeStartElement("Settings"); |
stream.writeStartElement("Macro"); |
for (int i = 0; i < macroCount; i++) { |
stream.writeStartElement("Macro_Entry"); |
stream.writeAttribute("Name", macroNameList[i]->text()); |
stream.writeTextElement("Value", macroValueList[i]->toPlainText()); |
int index = registeredKeyMacroIDs.indexOf(i); |
if (index >= 0) { |
stream.writeTextElement("Keybinding", registeredKeySequences[index].toString()); |
} else { |
stream.writeTextElement("Keybinding", ""); |
} |
stream.writeEndElement(); // Macro Entry |
} |
stream.writeEndElement(); // Macro |
stream.writeEndElement(); // Settings |
stream.writeEndDocument(); |
inputFile.close(); |
} |
void MacroWidget::Macro_ReadFromFile() |
{ |
int counter = 0; |
QString file = QFileDialog::getOpenFileName(this, "Settings XML File", lastKnownFilePath, "XML File (*.xml)"); |
QCoreApplication::processEvents(); // Wait for dialog to close |
if (file.size() == 0) return; |
Macro_Clear(); |
// If file was selected, save directory for next time |
QFileInfo fileInfo = QFileInfo(file); |
lastKnownFilePath = fileInfo.absolutePath(); |
QFile inputFile(file); |
if (!inputFile.open(QIODevice::ReadWrite | QIODevice::Text)) return; |
QXmlStreamReader stream(&inputFile); |
// Parse the XML file till we reach the end (or errors) |
while (!stream.atEnd() && !stream.hasError()) { |
QXmlStreamReader::TokenType token = stream.readNext(); |
// Ignore StartDocument |
if (token == QXmlStreamReader::StartDocument) continue; |
// Parse StartElements |
if (token == QXmlStreamReader::StartElement) { |
// Ignore elements <Settings> and <Macro> |
if (stream.name() == "Settings") continue; |
if (stream.name() == "Macro") continue; |
// Parse element <Macro_Entry> |
if (stream.name() == "Macro_Entry") { |
QString name, value, keybinding; |
// Read and save attribute value |
QXmlStreamAttributes attr = stream.attributes(); |
if (attr.hasAttribute("Name")) |
name = attr.value("Name").toString(); |
stream.readNext(); |
// Loop in this element to find all sub-elements |
while (!(stream.tokenType() == QXmlStreamReader::EndElement && stream.name() == "Macro_Entry")) { |
// Parse and save element value |
if (stream.tokenType() == QXmlStreamReader::StartElement) { |
if (stream.name() == "Value") { |
stream.readNext(); |
value = stream.text().toString(); |
} |
if (stream.name() == "Keybinding") { |
stream.readNext(); |
keybinding = stream.text().toString(); |
} |
} |
stream.readNext(); |
} |
// Write values to GUI |
if (counter == macroCount) |
Macro_AddEntry(); |
macroNameList[counter]->setText(name); |
macroValueList[counter]->setText(value); |
if (keybinding != "") { |
registeredKeySequences.append(QKeySequence(keybinding)); |
registeredKeyMacroIDs.append(counter); |
macroBtnKeyList[counter]->setText("Hotkey: " + keybinding); |
} |
counter++; |
} |
} |
} |
} |
bool MacroWidget::eventFilter(QObject *obj, QEvent *event) |
{ |
// Only process keyboard events |
if (event->type() == QEvent::KeyPress) { |
QKeyEvent *keyevent = static_cast<QKeyEvent*>(event); |
QKeySequence seq = keyevent->modifiers() + keyevent->key(); |
if ((keyevent->key() >= 0x21 && keyevent->key() <= 0x2F) || |
(keyevent->key() >= 0x3A && keyevent->key() <= 0x40) || |
(keyevent->key() >= 0x5E && keyevent->key() <= 0x7E) ) { |
seq = keyevent->key(); |
} |
if (connected) { |
// First check if key sequence matches any saved ones |
if (!registeredKeySequences.isEmpty()) { |
int index = registeredKeySequences.indexOf(seq); |
if (index >= 0) { |
Macro_InitTransmit(macroValueList[registeredKeyMacroIDs[index]]); |
return true; |
} |
} |
} |
// Then save key sequence if needed |
if (currKeyBindInfo.first != NULL) { |
// Ignore modifier keys and locks |
if (keyevent->key() == Qt::Key_Shift || keyevent->key() == Qt::Key_Control || |
keyevent->key() == Qt::Key_Meta || keyevent->key() == Qt::Key_Alt || |
keyevent->key() == Qt::Key_AltGr || keyevent->key() == Qt::Key_CapsLock || |
keyevent->key() == Qt::Key_NumLock || keyevent->key() == Qt::Key_ScrollLock) |
return true; |
// Reset on ESC key |
if (keyevent->key() == Qt::Key_Escape) { |
currKeyBindInfo.first->setText("Hotkey: None"); |
currKeyBindInfo.first->setDown(false); |
currKeyBindInfo.first->removeEventFilter(this); |
currKeyBindInfo = QPair<QPushButton*, int>(NULL, 0); |
return true; |
} |
// Otherwise save key sequence if it doesnt already exist |
if (!registeredKeySequences.contains(seq)) { |
registeredKeySequences.append(seq); |
registeredKeyMacroIDs.append(currKeyBindInfo.second); |
currKeyBindInfo.first->setText("Hotkey: " + seq.toString()); |
currKeyBindInfo.first->setDown(false); |
currKeyBindInfo.first->removeEventFilter(this); |
currKeyBindInfo = QPair<QPushButton*, int>(NULL, 0); |
return true; |
} |
} |
} |
return QWidget::eventFilter(obj, event); |
} |
/Misc Projects/PcMarlinInterface/MacroWidget.h |
---|
0,0 → 1,61 |
#ifndef MACROWIDGET_H |
#define MACROWIDGET_H |
#include "GlobalDefines.h" |
#define MACRO_DEFAULT_COUNT 4 |
class MacroWidget : public QWidget |
{ |
Q_OBJECT |
public: |
MacroWidget(QWidget *parent = 0); |
~MacroWidget(); |
QSize sizeHint() const; |
public slots: |
void Macro_EnableTransmit(void); |
void Macro_DisableTransmit(void); |
void Macro_InitTransmit(QWidget* t); |
void Macro_KeybindPrompt(int id); |
void Macro_AddEntry(void); |
void Macro_RemoveEntry(void); |
void Macro_Clear(void); |
void Macro_WriteToFile(void); |
void Macro_ReadFromFile(void); |
signals: |
void Macro_TransmitText(QByteArray data); |
protected: |
bool eventFilter(QObject *, QEvent *); |
private: |
int macroCount; |
bool connected; |
QString lastKnownFilePath; |
QPushButton *btnExport; |
QPushButton *btnImport; |
QPushButton *btnAddMacro; |
QPushButton *btnRemoveMacro; |
QPushButton *btnClear; |
QList<QLineEdit*> macroNameList; |
QList<QTextEdit*> macroValueList; |
QList<QPushButton*> macroBtnSendList; |
QList<QPushButton*> macroBtnKeyList; |
QList<QKeySequence> registeredKeySequences; |
QList<int> registeredKeyMacroIDs; |
QGridLayout *mainLayout; |
QHBoxLayout *ioLayout; |
QSignalMapper *sigmapTransmit; |
QSignalMapper *sigmapKeybind; |
QPair<QPushButton*,int> currKeyBindInfo; |
}; |
#endif // MACROWIDGET |
/Misc Projects/PcMarlinInterface/MainWindow.cpp |
---|
7,28 → 7,7 |
centralWidget = new QWidget(); |
setCentralWidget(centralWidget); |
// Serial data UI |
groupSerialData = new QGroupBox("Data"); |
textSerialData = new QTextEdit(); |
textSerialData->setCurrentFont(QFont("Consolas", 8)); |
textSerialData->append("Waiting for serial connection..."); |
textSerialData->setMinimumHeight(100); |
textSerialData->setReadOnly(true); |
textSerialTransmit = new QLineEdit(); |
textSerialTransmit->setFont(QFont("Consolas", 8)); |
btnSerialTransmit = new QPushButton("&Send"); |
btnSerialClear = new QPushButton("Clear"); |
QHBoxLayout *serialTransmitLayout = new QHBoxLayout(); |
serialTransmitLayout->addWidget(textSerialTransmit); |
serialTransmitLayout->addWidget(btnSerialTransmit); |
serialTransmitLayout->addWidget(btnSerialClear); |
QVBoxLayout *serialDataLayout = new QVBoxLayout(); |
serialDataLayout->addWidget(textSerialData); |
serialDataLayout->addLayout(serialTransmitLayout); |
groupSerialData->setLayout(serialDataLayout); |
// Macro controller |
// Misc button group |
groupMacro = new QGroupBox("Other"); |
btnMacro = new QPushButton("&Macros"); |
QHBoxLayout *macroLayout = new QHBoxLayout(); |
35,30 → 14,39 |
macroLayout->addWidget(btnMacro); |
groupMacro->setLayout(macroLayout); |
// Initialize serial controller |
serialController = new SerialController(); |
// Initialize serial widget |
serialInitWidget = new SerialWidget(); |
groupSerialInit = new QGroupBox("Serial Connection"); |
QGridLayout *serialInitLayout = new QGridLayout(); |
serialInitLayout->setContentsMargins(0, 0, 0, 0); |
serialInitLayout->addWidget(serialController); |
serialInitLayout->addWidget(serialInitWidget); |
groupSerialInit->setLayout(serialInitLayout); |
connect(serialController, SIGNAL(UpdateStatus(QString)), this, SLOT(UpdateSerialStatus(QString))); |
connect(serialInitWidget, SIGNAL(UpdateStatus(QString)), this, SLOT(UpdateSerialStatus(QString))); |
// Initialize macro controller |
// Initialize data widget |
textIOWidget = new TextIOWidget(); |
groupSerialData = new QGroupBox("Data"); |
QGridLayout *serialDataLayout = new QGridLayout(); |
serialDataLayout->setContentsMargins(0, 0, 0, 0); |
serialDataLayout->addWidget(textIOWidget); |
groupSerialData->setLayout(serialDataLayout); |
connect(serialInitWidget, SIGNAL(Serial_ReceivedByte(char)), textIOWidget, SLOT(Serial_ReceivedByte(char))); |
connect(serialInitWidget, SIGNAL(Serial_Connected()), textIOWidget, SLOT(Serial_EnableTransmit())); |
connect(serialInitWidget, SIGNAL(Serial_Disconnected()), textIOWidget, SLOT(Serial_DisableTransmit())); |
connect(textIOWidget, SIGNAL(Serial_TransmitByteArray(QByteArray)), serialInitWidget, SIGNAL(Serial_TransmitByteArray(QByteArray))); |
// Initialize macro widget |
macroDockWidget = new QDockWidget("Macro Controller", this); |
macroController = new MacroController(macroDockWidget); |
macroDockWidget->setWidget(macroController); |
macroWidget = new MacroWidget(macroDockWidget); |
macroDockWidget->setWidget(macroWidget); |
macroDockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); |
macroDockWidget->hide(); |
addDockWidget(Qt::RightDockWidgetArea, macroDockWidget); |
connect(macroController, SIGNAL(Macro_TransmitText(QString)), this, SLOT(Serial_PrepareTransmit(QString))); |
connect(serialController, SIGNAL(Serial_Connected()), macroController, SLOT(Macro_EnableTransmit())); |
connect(serialController, SIGNAL(Serial_Disconnected()), macroController, SLOT(Macro_DisableTransmit())); |
connect(macroWidget, SIGNAL(Macro_TransmitText(QByteArray)), textIOWidget, SLOT(Serial_PrepareTransmit(QByteArray))); |
connect(serialInitWidget, SIGNAL(Serial_Connected()), macroWidget, SLOT(Macro_EnableTransmit())); |
connect(serialInitWidget, SIGNAL(Serial_Disconnected()), macroWidget, SLOT(Macro_DisableTransmit())); |
// Connect local widgets |
connect(btnSerialTransmit, SIGNAL(clicked()), this, SLOT(Serial_PrepareTransmit())); |
connect(textSerialTransmit, SIGNAL(returnPressed()), btnSerialTransmit, SIGNAL(clicked())); |
connect(btnSerialClear, SIGNAL(clicked()), this, SLOT(Serial_ClearBtn())); |
connect(btnMacro, SIGNAL(clicked()), macroDockWidget->toggleViewAction(), SLOT(trigger())); |
// Main layout |
73,7 → 61,7 |
setWindowTitle("Marlin Controller"); |
setWindowIcon(QIcon(":/External/Resources/Icon_16.bmp")); |
labelSerialStatus = new QLabel("Serial: Disconnected"); |
labelSerialStatus = new QLabel("Disconnected"); |
statusBar()->addPermanentWidget(labelSerialStatus); |
} |
82,32 → 70,6 |
} |
void MainWindow::Serial_PrepareTransmit(QString string) |
{ |
if (string == "") { |
string = textSerialTransmit->text(); |
textSerialTransmit->setText(""); |
} |
emit Serial_TransmitString(string); |
textSerialData->setTextColor(Qt::darkBlue); |
QStringList cmds = string.split('\n'); |
for (int i = 0; i < cmds.size(); i++) { |
textSerialData->append("TX: " + cmds[i]); |
} |
} |
void MainWindow::Serial_ClearBtn() |
{ |
textSerialData->clear(); |
} |
void MainWindow::Serial_ReceivedString(QString string) |
{ |
textSerialData->setTextColor(Qt::darkRed); |
textSerialData->append("RX: " + string); |
} |
void MainWindow::UpdateStatus(QString string) |
{ |
statusBar()->showMessage(string, STATUS_TIMEOUT_MS); |
/Misc Projects/PcMarlinInterface/MainWindow.h |
---|
2,27 → 2,23 |
#define MAINWINDOW_H |
#include "GlobalDefines.h" |
#include "SerialController.h" |
#include "MacroController.h" |
#include "SerialWidget.h" |
#include "MacroWidget.h" |
#include "TextIOWidget.h" |
class MainWindow : public QMainWindow |
{ |
Q_OBJECT |
public: |
explicit MainWindow(QWidget *parent = 0); |
MainWindow(QWidget *parent = 0); |
~MainWindow(); |
public slots: |
void Serial_PrepareTransmit(QString string = ""); |
void Serial_ReceivedString(QString string); |
void Serial_ClearBtn(void); |
void UpdateStatus(QString string); |
void UpdateSerialStatus(QString string); |
signals: |
void Serial_TransmitString(QString string); |
void Serial_TransmitByteArray(QByteArray data); |
protected: |
30,19 → 26,16 |
QWidget *centralWidget; |
// Serial controller + UI |
SerialController *serialController; |
SerialWidget *serialInitWidget; |
QGroupBox *groupSerialInit; |
QPushButton *btnSerialConnect; |
// Serial data |
TextIOWidget *textIOWidget; |
QGroupBox *groupSerialData; |
QTextEdit *textSerialData; |
QLineEdit *textSerialTransmit; |
QPushButton *btnSerialTransmit; |
QPushButton *btnSerialClear; |
// Macro controller + UI |
MacroController *macroController; |
MacroWidget *macroWidget; |
QDockWidget *macroDockWidget; |
QGroupBox *groupMacro; |
QPushButton *btnMacro; |
/Misc Projects/PcMarlinInterface/PcMarlinInterface.pro |
---|
14,15 → 14,17 |
SOURCES += main.cpp \ |
MainWindow.cpp \ |
SerialController.cpp \ |
MacroController.cpp \ |
SerialHelper.cpp |
SerialHelper.cpp \ |
TextIOWidget.cpp \ |
MacroWidget.cpp \ |
SerialWidget.cpp |
HEADERS += GlobalDefines.h \ |
MainWindow.h \ |
SerialController.h \ |
MacroController.h \ |
SerialHelper.h |
SerialHelper.h \ |
TextIOWidget.h \ |
MacroWidget.h \ |
SerialWidget.h |
RESOURCES += Resources.qrc |
/Misc Projects/PcMarlinInterface/PcMarlinInterface.pro.user |
---|
1,6 → 1,6 |
<?xml version="1.0" encoding="UTF-8"?> |
<!DOCTYPE QtCreatorProject> |
<!-- Written by QtCreator 3.3.0, 2015-01-08T06:54:51. --> |
<!-- Written by QtCreator 3.3.0, 2015-01-08T10:53:44. --> |
<qtcreator> |
<data> |
<variable>EnvironmentId</variable> |
/Misc Projects/PcMarlinInterface/SerialHelper.cpp |
---|
30,7 → 30,7 |
QString stopBits, QString parity, QString flowControl) |
{ |
if (!connected) { |
emit UpdateStatus("Serial: Connecting to " + port); |
emit UpdateStatus("Connecting to " + port); |
serialPort = new QSerialPort(); |
connect(serialPort, SIGNAL(readyRead()), this, SLOT(Serial_ProcessIncomingData())); |
connect(serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(Serial_ProcessError(QSerialPort::SerialPortError))); |
80,7 → 80,7 |
serialPort->setDataTerminalReady(1); |
if (ok) { |
QString status = "Serial: Connected (%1 @ %2 D: %3 S: %4 P: %5 FC: %6)"; |
QString status = "Connected (%1 @ %2 D: %3 S: %4 P: %5 FC: %6)"; |
emit UpdateStatus(status.arg(port).arg(speed).arg(dataBits).arg(stopBits).arg(parity).arg(flowControl)); |
emit Serial_Connected(); |
} else |
96,7 → 96,7 |
delete serialPort; |
connected = false; |
if (!errored) |
emit UpdateStatus("Serial: Disconnected"); |
emit UpdateStatus("Disconnected"); |
emit Serial_Disconnected(); |
} |
106,9 → 106,9 |
serialPort->write(SERIAL_NEWLINE_CHAR); |
} |
void SerialHelper::Serial_TransmitByteArray(QByteArray buffer) |
void SerialHelper::Serial_TransmitByteArray(QByteArray data) |
{ |
serialPort->write(buffer); |
serialPort->write(data); |
} |
void SerialHelper::Serial_ProcessIncomingData() |
130,43 → 130,43 |
switch(error) { |
case QSerialPort::DeviceNotFoundError: |
emit UpdateStatus("Serial: (Error) Device not found"); |
emit UpdateStatus("(Error) Device not found"); |
return; |
case QSerialPort::PermissionError: |
emit UpdateStatus("Serial: (Error) Device already opened or lacking permission"); |
emit UpdateStatus("(Error) Device already opened or lacking permission"); |
return; |
case QSerialPort::OpenError: |
emit UpdateStatus("Serial: (Error) Device already opened"); |
emit UpdateStatus("(Error) Device already opened"); |
return; |
case QSerialPort::NotOpenError: |
emit UpdateStatus("Serial: (Error) Device not opened"); |
emit UpdateStatus("(Error) Device not opened"); |
return; |
case QSerialPort::ParityError: |
emit UpdateStatus("Serial: (Error) Parity error detected"); |
emit UpdateStatus("(Error) Parity error detected"); |
break; |
case QSerialPort::FramingError: |
emit UpdateStatus("Serial: (Error) Framing error detected"); |
emit UpdateStatus("(Error) Framing error detected"); |
break; |
case QSerialPort::BreakConditionError: |
emit UpdateStatus("Serial: (Error) Break condition detected"); |
emit UpdateStatus("(Error) Break condition detected"); |
break; |
case QSerialPort::WriteError: |
emit UpdateStatus("Serial: (Error) Unable to write to device"); |
emit UpdateStatus("(Error) Unable to write to device"); |
break; |
case QSerialPort::ReadError: |
emit UpdateStatus("Serial: (Error) Unable to read from device"); |
emit UpdateStatus("(Error) Unable to read from device"); |
break; |
case QSerialPort::ResourceError: |
emit UpdateStatus("Serial: (Error) Device missing or disconnected"); |
emit UpdateStatus("(Error) Device missing or disconnected"); |
break; |
case QSerialPort::UnsupportedOperationError: |
emit UpdateStatus("Serial: (Error) Operation not supported or prohibited"); |
emit UpdateStatus("(Error) Operation not supported or prohibited"); |
break; |
case QSerialPort::TimeoutError: |
emit UpdateStatus("Serial: (Error) Connection timeout"); |
emit UpdateStatus("(Error) Connection timeout"); |
break; |
case QSerialPort::UnknownError: |
emit UpdateStatus("Serial: (Error) Unknown error"); |
emit UpdateStatus("(Error) Unknown error"); |
break; |
default: |
break; |
/Misc Projects/PcMarlinInterface/SerialHelper.h |
---|
23,7 → 23,7 |
QString stopBits, QString parity, QString flowControl); |
void Serial_Disconnect(bool errored = false); |
void Serial_TransmitString(QString string); |
void Serial_TransmitByteArray(QByteArray buffer); |
void Serial_TransmitByteArray(QByteArray data); |
// Local processing of received data |
void Serial_ProcessIncomingData(void); |
/Misc Projects/PcMarlinInterface/SerialWidget.cpp |
---|
0,0 → 1,217 |
#include "SerialWidget.h" |
SerialWidget::SerialWidget(QWidget *parent) : QWidget(parent) |
{ |
// Serial connection UI |
btnSerialConnect = new QPushButton("&Connect"); |
btnSerialRefresh = new QPushButton("&Refresh"); |
labelSerialPort = new QLabel("Serial Port:"); |
labelSerialSpeed = new QLabel("Baud Rate:"); |
labelSerialDataBits = new QLabel("Data:"); |
labelSerialStopBits = new QLabel("Stop:"); |
labelSerialParity = new QLabel("Parity Bit:"); |
labelSerialFlowControl = new QLabel("Flow Control:"); |
cboxSerialPort = new QComboBox(); |
cboxSerialPort->setMinimumWidth(80); |
cboxSerialSpeed = new QComboBox(); |
cboxSerialSpeed->setEditable(true); |
cboxSerialSpeed->setValidator(new QIntValidator(0, 100000000, this)); |
cboxSerialDataBits = new QComboBox(); |
cboxSerialDataBits->setMaximumWidth(60); |
cboxSerialStopBits = new QComboBox(); |
cboxSerialStopBits->setMaximumWidth(60); |
cboxSerialParity = new QComboBox(); |
cboxSerialFlowControl = new QComboBox(); |
cboxSerialFlowControl->setMinimumWidth(70); |
QGridLayout *serialSettingsLayout = new QGridLayout(); |
serialSettingsLayout->addWidget(btnSerialConnect, 0, 0); |
serialSettingsLayout->addWidget(labelSerialPort, 0, 1); |
serialSettingsLayout->addWidget(cboxSerialPort, 0, 2); |
serialSettingsLayout->addWidget(labelSerialDataBits, 0, 3); |
serialSettingsLayout->addWidget(cboxSerialDataBits, 0, 4); |
serialSettingsLayout->addWidget(labelSerialParity, 0, 5); |
serialSettingsLayout->addWidget(cboxSerialParity, 0, 6); |
serialSettingsLayout->addWidget(btnSerialRefresh, 1, 0); |
serialSettingsLayout->addWidget(labelSerialSpeed, 1, 1); |
serialSettingsLayout->addWidget(cboxSerialSpeed, 1, 2); |
serialSettingsLayout->addWidget(labelSerialStopBits, 1, 3); |
serialSettingsLayout->addWidget(cboxSerialStopBits, 1, 4); |
serialSettingsLayout->addWidget(labelSerialFlowControl, 1, 5); |
serialSettingsLayout->addWidget(cboxSerialFlowControl, 1, 6); |
setLayout(serialSettingsLayout); |
serialHelper = new SerialHelper(); |
serialThread = new QThread(); |
serialHelper->moveToThread(serialThread); |
connect(serialHelper, SIGNAL(UpdateStatus(QString)), this, SIGNAL(UpdateStatus(QString))); |
connect(this, SIGNAL(Serial_QueryParameters()), serialHelper, SLOT(Serial_QueryParameters())); |
connect(serialHelper, SIGNAL(Serial_UpdateParameters(QStringList,QStringList,QStringList,QStringList,QStringList,QStringList)), |
this, SLOT(Serial_UpdateParameters(QStringList,QStringList,QStringList,QStringList,QStringList,QStringList))); |
connect(this, SIGNAL(Serial_Connect(QString,QString,QString,QString,QString,QString)), |
serialHelper, SLOT(Serial_Connect(QString,QString,QString,QString,QString,QString))); |
connect(serialHelper, SIGNAL(Serial_Connected()), this, SIGNAL(Serial_Connected())); |
connect(serialHelper, SIGNAL(Serial_Connected()), this, SLOT(Serial_LocalConnected())); |
connect(this, SIGNAL(Serial_Disconnect()), serialHelper, SLOT(Serial_Disconnect())); |
connect(serialHelper, SIGNAL(Serial_Disconnected()), this, SIGNAL(Serial_Disconnected())); |
connect(serialHelper, SIGNAL(Serial_Disconnected()), this, SLOT(Serial_LocalDisconnected())); |
connect(this, SIGNAL(Serial_TransmitByteArray(QByteArray)), serialHelper, SLOT(Serial_TransmitByteArray(QByteArray))); |
connect(serialHelper, SIGNAL(Serial_ReceivedByte(char)), this, SIGNAL(Serial_ReceivedByte(char))); |
connect(serialThread, SIGNAL(finished()), serialHelper, SLOT(deleteLater())); |
serialThread->start(); |
connect(btnSerialConnect, SIGNAL(clicked()), this, SLOT(Serial_ConnectToggleBtn())); |
connect(btnSerialRefresh, SIGNAL(clicked()), this, SIGNAL(Serial_QueryParameters())); |
emit Serial_QueryParameters(); |
Serial_LocalDisconnected(); |
} |
SerialWidget::~SerialWidget() |
{ |
serialThread->quit(); |
} |
void SerialWidget::Serial_UpdateParameters(QStringList ports, QStringList speeds, QStringList dataBits, |
QStringList stopBits, QStringList parity, QStringList flowControl) |
{ |
QString currPort = cboxSerialPort->currentText(); |
cboxSerialPort->clear(); |
cboxSerialPort->addItems(ports); |
if (currPort != "" && ports.contains(currPort)) |
cboxSerialPort->setCurrentText(currPort); |
QString currSpeed = cboxSerialSpeed->currentText(); |
cboxSerialSpeed->clear(); |
cboxSerialSpeed->addItems(speeds); |
if (currSpeed != "") cboxSerialSpeed->setCurrentText(currSpeed); |
int currData = cboxSerialDataBits->currentIndex(); |
cboxSerialDataBits->clear(); |
cboxSerialDataBits->addItems(dataBits); |
if (currData >= 0) cboxSerialDataBits->setCurrentIndex(currData); |
int currStop = cboxSerialStopBits->currentIndex(); |
cboxSerialStopBits->clear(); |
cboxSerialStopBits->addItems(stopBits); |
if (currStop >= 0) cboxSerialStopBits->setCurrentIndex(currStop); |
int currParity = cboxSerialParity->currentIndex(); |
cboxSerialParity->clear(); |
cboxSerialParity->addItems(parity); |
if (currParity >= 0) cboxSerialParity->setCurrentIndex(currParity); |
int currFlow = cboxSerialFlowControl->currentIndex(); |
cboxSerialFlowControl->clear(); |
cboxSerialFlowControl->addItems(flowControl); |
if (currFlow >= 0) cboxSerialFlowControl->setCurrentIndex(currFlow); |
} |
void SerialWidget::Serial_LocalConnected() |
{ |
btnSerialConnect->setText("&Disconnect"); |
// cboxSerialPort->setEnabled(false); |
// cboxSerialSpeed->setEnabled(false); |
// cboxSerialDataBits->setEnabled(false); |
// cboxSerialStopBits->setEnabled(false); |
// cboxSerialParity->setEnabled(false); |
// cboxSerialFlowControl->setEnabled(false); |
// btnSerialRefresh->setEnabled(false); |
btnSerialRefresh->hide(); |
labelSerialPort->hide(); |
labelSerialSpeed->hide(); |
labelSerialDataBits->hide(); |
labelSerialStopBits->hide(); |
labelSerialParity->hide(); |
labelSerialFlowControl->hide(); |
cboxSerialPort->hide(); |
cboxSerialSpeed->hide(); |
cboxSerialDataBits->hide(); |
cboxSerialStopBits->hide(); |
cboxSerialParity->hide(); |
cboxSerialFlowControl->hide(); |
} |
void SerialWidget::Serial_LocalDisconnected() |
{ |
btnSerialConnect->setText("&Connect"); |
// cboxSerialPort->setEnabled(true); |
// cboxSerialSpeed->setEnabled(true); |
// cboxSerialDataBits->setEnabled(true); |
// cboxSerialStopBits->setEnabled(true); |
// cboxSerialParity->setEnabled(true); |
// cboxSerialFlowControl->setEnabled(true); |
// btnSerialRefresh->setEnabled(true); |
btnSerialRefresh->show(); |
labelSerialPort->show(); |
labelSerialSpeed->show(); |
labelSerialDataBits->show(); |
labelSerialStopBits->show(); |
labelSerialParity->show(); |
labelSerialFlowControl->show(); |
cboxSerialPort->show(); |
cboxSerialSpeed->show(); |
cboxSerialDataBits->show(); |
cboxSerialStopBits->show(); |
cboxSerialParity->show(); |
cboxSerialFlowControl->show(); |
} |
void SerialWidget::Serial_ConnectToggleBtn() |
{ |
if (serialHelper->connected) { |
emit Serial_Disconnect(); |
} else { |
if (cboxSerialPort->currentText() != "" && cboxSerialSpeed->currentText() != "") { |
emit Serial_Connect(cboxSerialPort->currentText(), cboxSerialSpeed->currentText(), cboxSerialDataBits->currentText(), |
cboxSerialStopBits->currentText(), cboxSerialParity->currentText(), cboxSerialFlowControl->currentText()); |
} |
} |
} |
//void SerialController::Serial_ProcessIncomingData() |
//{ |
// char tmpBuffer[SERIAL_BUFFER_SIZE]; |
// int len = serialPort->read(tmpBuffer, sizeof(tmpBuffer)); |
// while (len > 0) { |
// for (int i = 0; i < len; i++) { |
// // Save received data into local buffer |
// bufferIn[bufferInIndex] = tmpBuffer[i]; |
// // If newline char is received, end current string |
// if (tmpBuffer[i] == '\n') { |
// if (bufferInOverflow) |
// currString.append(QString::fromLocal8Bit(bufferIn, bufferInIndex)); |
// else |
// currString = QString::fromLocal8Bit(bufferIn, bufferInIndex); |
// bufferInOverflow = false; |
// bufferInIndex = 0; |
// emit Serial_ReceivedString(currString); |
// } else { |
// bufferInIndex++; |
// } |
// // If received string is larger than our serial buffer, append to previous data |
// if (bufferInIndex == SERIAL_BUFFER_SIZE-1) { |
// bufferIn[SERIAL_BUFFER_SIZE-1] = 0x0; |
// if (bufferInOverflow) |
// currString.append(QString::fromLocal8Bit(bufferIn, bufferInIndex)); |
// else |
// currString = QString::fromLocal8Bit(bufferIn, bufferInIndex); |
// bufferInOverflow = true; |
// bufferInIndex = 0; |
// } |
// } |
// // Check if there is more data to be read from the serial port |
// len = serialPort->read(tmpBuffer, sizeof(tmpBuffer)); |
// } |
//} |
/Misc Projects/PcMarlinInterface/SerialWidget.h |
---|
0,0 → 1,58 |
#ifndef SERIALWIDGET_H |
#define SERIALWIDGET_H |
#include "GlobalDefines.h" |
#include "SerialHelper.h" |
class SerialWidget : public QWidget |
{ |
Q_OBJECT |
public: |
SerialWidget(QWidget *parent = 0); |
~SerialWidget(); |
public slots: |
// Inbound from SerialHelper |
void Serial_UpdateParameters(QStringList ports, QStringList speeds, QStringList dataBits, |
QStringList stopBits, QStringList parity, QStringList flowControl); |
// Local GUI processing |
void Serial_ConnectToggleBtn(void); |
void Serial_LocalConnected(void); |
void Serial_LocalDisconnected(void); |
signals: |
// Outbound to SerialHelper |
void Serial_QueryParameters(void); |
void Serial_Connect(QString port, QString speed, QString dataBits, |
QString stopBits, QString parity, QString flowControl); |
void Serial_Disconnect(void); |
void Serial_TransmitByteArray(QByteArray data); |
// Outbound to MainWindow |
void Serial_ReceivedByte(char byte); |
void Serial_Connected(void); |
void Serial_Disconnected(void); |
void UpdateStatus(QString string); |
private: |
SerialHelper *serialHelper; |
QThread *serialThread; |
QPushButton *btnSerialConnect; |
QPushButton *btnSerialRefresh; |
QLabel *labelSerialPort; |
QLabel *labelSerialSpeed; |
QLabel *labelSerialDataBits; |
QLabel *labelSerialStopBits; |
QLabel *labelSerialParity; |
QLabel *labelSerialFlowControl; |
QComboBox *cboxSerialPort; |
QComboBox *cboxSerialSpeed; |
QComboBox *cboxSerialDataBits; |
QComboBox *cboxSerialStopBits; |
QComboBox *cboxSerialParity; |
QComboBox *cboxSerialFlowControl; |
}; |
#endif // SERIALWIDGET_H |
/Misc Projects/PcMarlinInterface/TextIOWidget.cpp |
---|
0,0 → 1,79 |
#include "TextIOWidget.h" |
TextIOWidget::TextIOWidget(QWidget *parent) : QWidget(parent) |
{ |
// Serial data UI |
textSerialData = new QTextEdit(); |
textSerialData->setCurrentFont(QFont("Consolas", 8)); |
textSerialData->append("Waiting for serial connection..."); |
textSerialData->setMinimumSize(400, 100); |
textSerialData->setReadOnly(true); |
textSerialTransmit = new QLineEdit(); |
textSerialTransmit->setEnabled(false); |
textSerialTransmit->setFont(QFont("Consolas", 8)); |
btnSerialTransmit = new QPushButton("&Send"); |
btnSerialTransmit->setEnabled(false); |
btnSerialClear = new QPushButton("Clear"); |
QHBoxLayout *serialTransmitLayout = new QHBoxLayout(); |
serialTransmitLayout->addWidget(textSerialTransmit); |
serialTransmitLayout->addWidget(btnSerialTransmit); |
serialTransmitLayout->addWidget(btnSerialClear); |
QVBoxLayout *serialDataLayout = new QVBoxLayout(); |
serialDataLayout->addWidget(textSerialData); |
serialDataLayout->addLayout(serialTransmitLayout); |
setLayout(serialDataLayout); |
connect(btnSerialTransmit, SIGNAL(clicked()), this, SLOT(Serial_PrepareTransmit())); |
connect(textSerialTransmit, SIGNAL(returnPressed()), btnSerialTransmit, SIGNAL(clicked())); |
connect(btnSerialClear, SIGNAL(clicked()), this, SLOT(Serial_ClearBtn())); |
Serial_DisableTransmit(); |
} |
TextIOWidget::~TextIOWidget() |
{ |
} |
void TextIOWidget::Serial_PrepareTransmit(QByteArray data) |
{ |
QString str; |
if (data.isEmpty()) { |
str = textSerialTransmit->text(); |
textSerialTransmit->setText(""); |
} else { |
str = QString(data); |
} |
emit Serial_TransmitByteArray(str.toUtf8()); |
textSerialData->setTextColor(Qt::darkBlue); |
QStringList cmds = str.split('\n'); |
for (int i = 0; i < cmds.size(); i++) { |
textSerialData->append("TX: " + cmds[i]); |
} |
} |
void TextIOWidget::Serial_ReceivedByte(char byte) |
{ |
textSerialData->setTextColor(Qt::darkRed); |
textSerialData->append("RX: " + QString(byte)); |
} |
void TextIOWidget::Serial_ClearBtn() |
{ |
textSerialData->clear(); |
} |
void TextIOWidget::Serial_EnableTransmit() |
{ |
textSerialTransmit->setEnabled(true); |
btnSerialTransmit->setEnabled(true); |
} |
void TextIOWidget::Serial_DisableTransmit() |
{ |
textSerialTransmit->setEnabled(false); |
btnSerialTransmit->setEnabled(false); |
} |
/Misc Projects/PcMarlinInterface/TextIOWidget.h |
---|
0,0 → 1,30 |
#ifndef TEXTIOWIDGET_H |
#define TEXTIOWIDGET_H |
#include "GlobalDefines.h" |
class TextIOWidget : public QWidget |
{ |
Q_OBJECT |
public: |
TextIOWidget(QWidget *parent = 0); |
~TextIOWidget(); |
public slots: |
void Serial_PrepareTransmit(QByteArray data = QByteArray()); |
void Serial_ReceivedByte(char byte); |
void Serial_ClearBtn(void); |
void Serial_EnableTransmit(void); |
void Serial_DisableTransmit(void); |
signals: |
void Serial_TransmitByteArray(QByteArray data); |
private: |
QTextEdit *textSerialData; |
QLineEdit *textSerialTransmit; |
QPushButton *btnSerialTransmit; |
QPushButton *btnSerialClear; |
}; |
#endif // TEXTIOWIDGET_H |