mainwindow.cpp

#include "mainwindow.h"
#include "StatusDialog.h"
#include "qextserialenumerator.h"
#include "Sleeper.h"
#include "p1loader.h"

#ifndef QT5
#define QStringLiteral QLatin1String
#endif

#define AUTOPORT "AUTO"

/**
 * Having some global symbols may seem a little odd, but serves a purpose.
 * This is the IDE debug editor where all qDebug() output goes. The output is
 * used for IDE debug information displayed by Build Status with CTRL+SHIFT+D.
 */
#undef  IDEDEBUG
//#define IDEDEBUG


QPlainTextEdit *debugStatus;

void clearDebugStatus()
{
#if defined(IDEDEBUG)
    debugStatus->setPlainText("");
#endif
}

#if defined(IDEDEBUG)
void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
    debugStatus->appendPlainText(msg);
    debugStatus->setFont(QFont("Courier New"));
}
#endif

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), statusMutex(QMutex::Recursive), statusDone(true)
{
#if defined(IDEDEBUG)
    debugStatus = new QPlainTextEdit(this);
    debugStatus->setLineWrapMode(QPlainTextEdit::NoWrap);
    ideDebugFrame = new QDialog(this);
    QVBoxLayout *lay = new QVBoxLayout();
    ideDebugFrame->setLayout(lay);
    ideDebugFrame->setWindowTitle("Serial Debug");
    setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint);
    lay->addWidget(debugStatus);
    lay->setMargin(0);
    lay->setSpacing(0);
    ideDebugFrame->resize(700,300);
    ideDebugFrame->hide();
    qInstallMessageHandler(myMessageOutput);
#endif
}

void MainWindow::init()
{
    /* the program name used in all windows/diaglogs */
    programName = QString(PropellerIdeGuiKey);

    /* setup application registry info */
    QCoreApplication::setOrganizationName(publisherKey);
    QCoreApplication::setOrganizationDomain(publisherComKey);
    QCoreApplication::setApplicationName(PropellerIdeGuiKey);

    /* global settings */
    settings = new QSettings(publisherKey, PropellerIdeGuiKey, this);

    /* setup properties dialog */
    propDialog = new Properties(this);
    connect(propDialog,SIGNAL(accepted()),this,SLOT(propertiesAccepted()));
    connect(propDialog,SIGNAL(openFontDialog()),this,SLOT(fontDialog()));
    connect(propDialog->getTabSpaceLedit(),SIGNAL(textChanged(QString)), this, SLOT(tabSpacesChanged()));

    projectModel = NULL;
    referenceModel = NULL;

    spinBuilder = new SpinBuilder();

    connect(spinBuilder,SIGNAL(compilerErrorInfo(QString,int)), this, SLOT(highlightFileLine(QString,int)));

    /*
    font.setFamily("Parallax");
    font.setFixedPitch(true);
    font.setPointSize(10);
     */

    // Parallax font is buggy. 26, 36, and 48 are bad.
    QFontDatabase::addApplicationFont(":/images/parallax2-bold.ttf");
#ifdef Q_OS_WIN
    QFontDatabase::addApplicationFont(":/images/Parallax.ttf");
#endif

    /* setup user's editor font */
    QVariant fontv = settings->value(editorFontKey);
    if(fontv.canConvert(QVariant::Font)) {
        QString family = fontv.toString();
        editorFont = QFont(family);
        qDebug() << "Settings Editor Font" << editorFont.family();
    }
    else {
        int fontsz = 12;
#ifdef Q_WS_MAC
        fontsz = 14;
#endif
        editorFont = QFont("Parallax2", fontsz, QFont::Normal, false);
        settings->setValue(fontSizeKey,fontsz);
    }

    fontv = settings->value(fontSizeKey);
    if(fontv.canConvert(QVariant::Int)) {
        int size = fontv.toInt();
        editorFont.setPointSize(size);
    }
    else {
        editorFont.setPointSize(10);
    }

    /* setup gui components */
    setupFileMenu();
    setupHelpMenu();
    setupToolBars();

    /* main container */
    setWindowTitle(programName);
    QSplitter *vsplit = new QSplitter(this);
    setCentralWidget(vsplit);

    /* minimum window height */
    this->setMinimumHeight(500);

    /* project tools */
    setupProjectTools(vsplit);

    /* start with an empty file if fresh install */
    newFile();

    /* status bar for progressbar */
    QStatusBar *statusBar = new QStatusBar();

    sizeLabel = new QLabel;
    sizeLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
    msgLabel  = new QLabel;

    progress = new QProgressBar();
    //progress->setMaximumSize(100,25);
    progress->setValue(0);
    progress->setMinimum(0);
    progress->setMaximum(100);
    progress->setTextVisible(false);
    progress->setVisible(false);

    statusBar->addPermanentWidget(msgLabel,70);
    statusBar->addPermanentWidget(sizeLabel,15);
    statusBar->addPermanentWidget(progress,15);

    this->setStatusBar(statusBar);

    /* get last geometry. using x,y,w,h is unreliable.
     */
    QVariant geov = settings->value(mainWindowGeometry);
    if(geov.canConvert(QVariant::ByteArray)) {
        // byte array convert is always possible
        QByteArray geo = geov.toByteArray();
        // restoreGeometry makes sure the array is valid
        this->restoreGeometry(geo);
    }
    else {
        this->resize(800,600);
    }

    QApplication::processEvents();

    /* Get app settings at startup and before any compiler call.
     * Some people want to be prepared, others just want to hack
     * their way through life ... i guess it's fun.
     * The latter is most common, so let's do it like that.
     * In this case, we need the properties if their set, but we can't complain.
     */
    getApplicationSettings(false);

    initBoardTypes();

    /* setup the terminal dialog box */
    term = new Terminal2(this);

    QVariant gv = settings->value(termGeometryKey);
    if(gv.canConvert(QVariant::ByteArray)) {
        QByteArray geo = gv.toByteArray();
        term->restoreGeometry(geo);
    }

    /* setup the port listener */
    portListener = new PortListener(this, term->getEditor());
    portListener->setTerminalWindow(term->getEditor());
    connect(spinBuilder,SIGNAL(terminalReceived(QString)), portListener, SLOT(appendConsole(QString)));

    term->setPortListener(portListener);

    //term->setWindowTitle(QString(ASideGuiKey)+" "+tr("Simple Terminal"));
    // education request that the window title be SimpleIDE Terminal
    term->setWindowTitle(QString(PropellerIdeGuiKey)+" "+tr("Terminal"));

    connect(term,SIGNAL(accepted()),this,SLOT(terminalClosed()));
    connect(term,SIGNAL(rejected()),this,SLOT(terminalClosed()));

    /* get available ports at startup */
    enumeratePorts();

    portConnectionMonitor = new PortConnectionMonitor();
    connect(portConnectionMonitor, SIGNAL(portChanged()), this, SLOT(enumeratePortsEvent()));

    /* Do this before using the dialog. */
    statusDialog = new StatusDialog(this);
    portListener->setStatusDialog(statusDialog);

    connect(this,SIGNAL(signalStatusDone(bool)),this,SLOT(setStatusDone(bool)));

    // Show GUI now
    QApplication::processEvents();
    this->show();

    openLastFile();
}

int  MainWindow::isPackageSource(QString fileName)
{
    QString dir = QFileInfo(fileName).absolutePath();
    QString file= dir+"/tmp_"+QString("%1").arg(QDateTime::currentDateTime().toTime_t());

    bool fw = QFileInfo(fileName).isWritable();
    bool pw = false;

    QFile wf(file);
    if(wf.open(QFile::WriteOnly)) {
        wf.close();
        pw = true;
        wf.remove();
    }
    return fw && pw;
}

int  MainWindow::extractSource(QString &fileName)
{
    fileName = this->saveAsFile();

    if(fileName.length() > 0) {
        return isPackageSource(fileName);
    }
    return 0;
}

// call from main ?
void MainWindow::openLastFile()
{
    /* load the last file into the editor to make user happy */
    QString welcome = propDialog->getSpinLibraryString()+"Welcome.spin";
    QString fileName;
    QVariant lastfilev = settings->value(lastFileNameKey, welcome);
    if(!lastfilev.isNull()) {
        if(lastfilev.canConvert(QVariant::String)) {
            if(lastfilev.toString().length() > 0) {
                fileName = lastfilev.toString();
            }
            openFileName(fileName);
            QApplication::processEvents();

            if(fileName.compare(welcome) == 0) {
                QMessageBox::information(this,tr("Welcome to PropellerIDE"),
                    tr("The Welcome.spin file must be saved to a user folder where you can change it.")+" "+
                    tr("The installed package location is not writable by most users.")+"\n\n"+
                    tr("Please note that opening a library file from the installed package will also require saving to a user folder for compiling or modifications.")+" "+
                    tr("Don't worry, you will be reminded if necessary.")+"\n\n"+
                    tr("The Save As dialog will now open to let you choose a working folder."));
                lastDirectory = QDir::homePath()+"/Documents";
                if(!QFile::exists(lastDirectory)) {
                    lastDirectory = QDir::homePath();
                }
                fileName = saveAsFile();
            }
        }
    }

    /* load the last directory to make user happy */
    lastDirectory = filePathName(fileName);
    QVariant lastdirv = settings->value(lastDirectoryKey, lastDirectory);
    if(!lastdirv.isNull()) {
        if(lastdirv.canConvert(QVariant::String)) {
            if(lastdirv.toString().length() > 0) {
                lastDirectory = lastdirv.toString();
            }
        }
    }


    /** ******************************************************************
     *                  MainWindow::MainWindow all done.
     * ******************************************************************/
}

void MainWindow::keyHandler(QKeyEvent* event)
{
#if 0
    //qDebug() << "MainWindow::keyHandler";
    int key = event->key();
    term->print(QByteArray(event->text().toLatin1()));
    switch(key)
    {
#if defined(Q_OS_WIN32)
    // stupid windows
    case Qt::Key_Enter:
        key = '\r';
        break;
    case Qt::Key_Return:
        key = '\n';
        break;
#else
    case Qt::Key_Enter:
        key = '\n';
        break;
    case Qt::Key_Return:
        key = '\r';
        break;
#endif
    case Qt::Key_Backspace:
        key = '\b';
        break;
    default:
        if(key & Qt::Key_Escape)
            return;
        QChar c = event->text().at(0);
        key = (int)c.toLatin1();
        break;
    }
    QByteArray barry;
    barry.append((char)key);
    portListener->send(barry);
#endif
}

void MainWindow::terminalEditorTextChanged()
{
    QString text = termEditor->toPlainText();
}

/*
 * get the application settings from the registry for compile/startup
 */
void MainWindow::getApplicationSettings(bool complain)
{
    QDir dir(this->lastDirectory);
    QFile file;
    QVariant compv;

    compv = settings->value(spinCompilerKey);
    if(compv.canConvert(QVariant::String)) {
        spinCompiler = compv.toString();
        spinCompiler = dir.fromNativeSeparators(spinCompiler);
    }
    if(complain && !file.exists(spinCompiler)) {
        propDialog->showProperties(this->lastDirectory);
    }
    compv = settings->value(spinLoaderKey);
    if(compv.canConvert(QVariant::String)) {
        spinLoader = compv.toString();
        spinLoader = dir.fromNativeSeparators(spinLoader);
    }

    /* get the compiler path */
    spinCompilerPath = filePathName(spinCompiler);
    spinCompilerPath = dir.fromNativeSeparators(spinCompilerPath);

    /* get the include path and config file set by user */
    QVariant incv;

    incv = settings->value(spinIncludesKey);
    if(incv.canConvert(QVariant::String)) {
        spinIncludes = incv.toString();
        spinIncludes = dir.fromNativeSeparators(spinIncludes);
    }
}

/**
 * @brief MainWindow::exitSave
 * @return false to cancel exit
 */
bool MainWindow::exitSave()
{
    bool saveAll = false;
    QMessageBox mbox(QMessageBox::Question, "Save File?", "",
                     QMessageBox::Discard | QMessageBox::Save | QMessageBox::SaveAll | QMessageBox::Cancel, this);

    for(int tab = editorTabs->count()-1; tab > -1; tab--)
    {
        QString tabName = editorTabs->tabText(tab);
        if(tabName.at(tabName.length()-1) == '*')
        {
            mbox.setInformativeText(tr("Save File: ") + tabName.mid(0,tabName.indexOf(" *")) + tr(" ?"));
            if(saveAll)
            {
                saveFileByTabIndex(tab);
            }
            else
            {
                int ret = mbox.exec();
                switch (ret) {
                    case QMessageBox::Cancel:
                        return false;
                        break;
                    case QMessageBox::Discard:
                        // Don't Save was clicked
                        return true;
                        break;
                    case QMessageBox::Save:
                        // Save was clicked
                        saveFileByTabIndex(tab);
                        break;
                    case QMessageBox::SaveAll:
                        // save all was clicked
                        saveAll = true;
                        break;
                    default:
                        // should never be reached
                        break;
                }
            }
        }
    }
    return true;
}

void MainWindow::quitProgram()
{
    QCloseEvent e;
    closeEvent(&e);
}

void MainWindow::closeEvent(QCloseEvent *e)
{
    if(!exitSave()) {
        if(e) e->ignore();
        return;
    }

    portListener->close();
    portConnectionMonitor->stop();

    QString filestr = editorTabs->tabToolTip(editorTabs->currentIndex());

    if(settings->value(useKeys).toInt())
    {
        settings->setValue(lastFileNameKey,filestr);
        settings->setValue(lastDirectoryKey, lastDirectory);

        // save user's font info
        qDebug() << "Saving Editor Font" << editorFont.family();
        QString fontstr = editorFont.family();
        settings->setValue(editorFontKey,fontstr);
        int fontsize = editorFont.pointSize();
        settings->setValue(fontSizeKey,fontsize);

        // save user's width/height
        QByteArray geo = this->saveGeometry();
        settings->setValue(mainWindowGeometry,geo);
    }
    if(e) e->accept();
    qApp->exit(0);
}

void MainWindow::newFileAction()
{
    newFile();
    int tab = editorTabs->count()-1;
    setEditorCodeType(getEditor(tab), QString("UTF-16"));
}

void MainWindow::newFile()
{
    changeTabDisable = true;
    fileChangeDisable = true;
    editorTabs->addTab(createEditor(),(const QString&)untitledstr);
	int tab = editorTabs->count()-1;
    editorTabs->setCurrentIndex(tab);
    editorTabs->setTabToolTip(tab, QString(""));
    delete projectModel;
    projectModel = new TreeModel("", this);
    if(leftSplit->isVisible()) {
        delete referenceModel;
        referenceModel = new TreeModel("", this);
    }
    spinParser.clearDB();
    fileChangeDisable = false;
    changeTabDisable = false;
}

void MainWindow::openFile(const QString &path)
{
    QString fileName = path;

    if (fileName.isNull())
        fileName = QFileDialog::getOpenFileName(this,
            tr("Open File"), lastDirectory, programName + " Files (*.spin);;All Files (*)");
    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
    openFileName(fileName);
    lastDirectory = filePathName(fileName);
    QApplication::processEvents();
    QApplication::restoreOverrideCursor();
}

bool MainWindow::isFileUTF16(QFile *file)
{
    char str[2];
    file->read(str,2);
    file->seek(0);
    if(str[0] == -1 && str[1] == -2) {
        return true;
    }
    return false;
}

void MainWindow::openFileName(QString fileName)
{
    QString data;
    if (!fileName.isEmpty()) {
        QFile file(fileName);
        if (file.open(QFile::ReadOnly))
        {
            QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

            QTextStream in(&file);
            if(this->isFileUTF16(&file)) {
                in.setCodec("UTF-16");
            }
            else {
                in.setCodec("UTF-8");
            }
            data = in.readAll();
            file.close();

            QApplication::processEvents();
            QApplication::restoreOverrideCursor();

            QString sname = this->shortFileName(fileName);
            if(editorTabs->count()>0) {
                for(int n = editorTabs->count()-1; n > -1; n--) {
                    if(editorTabs->tabText(n) == sname) {
                        setEditor(n, sname, fileName, data);
                        setEditorCodeType(getEditor(n), QString(in.codec()->name()));
                        setProject();
                        return;
                    }
                }
            }
            if(editorTabs->tabText(0) == untitledstr) {
                setEditor(0, sname, fileName, data);
                setEditorCodeType(getEditor(0), QString(in.codec()->name()));
                setProject();
                return;
            }
            newFile();
            setEditor(editorTabs->count()-1, sname, fileName, data);
            setEditorCodeType(getEditor(0), QString(in.codec()->name()));
            setProject();
        }
    }
}

/**
 * @brief MainWindow::saveAsCodec
 * Forces save to UTF-16 for now.
 * May want to choose type later depending on the editor's type.
 * @param fileName The full fileName with path to save.
 * @param data The file data
 * @return false if file could not be opened.
 */
bool MainWindow::saveAsCodec(QString fileName, Editor *ed)
{
    QFile file(fileName);
    if (file.open(QFile::WriteOnly)) {
        QTextStream os(&file);
        QString data = ed->toPlainText();

        setCurrentFile(fileName);

        if(ed->getCodeType() == Editor::CodeTypeUTF16) {
            os.setGenerateByteOrderMark(true);
            os.setCodec("UTF-16");
            os << data;
        }
        else {
            os.setCodec("UTF-8");
            os << data.toUtf8();
        }
\
        file.close();
        QString tab = editorTabs->tabText(editorTabs->currentIndex());
        if(tab.endsWith("*")) {
            tab = tab.mid(0,tab.length());
            tab = tab.trimmed();
            editorTabs->setTabText(editorTabs->currentIndex(),tab);
        }
        return true;
    }
    else {
        QMessageBox::information(this, tr("Can't Save File"), tr("Can't save file ")+fileName, QMessageBox::Ok);
    }
    return false;
}

void MainWindow::saveFile()
{
    try {
        int n = this->editorTabs->currentIndex();
        QString fileName = editorTabs->tabToolTip(n);
        if (fileName.isEmpty()) {
            saveAsFile(fileName);
            if (fileName.isEmpty())
                return;
        }
        Editor *ed = getEditor(n);
        this->editorTabs->setTabText(n,shortFileName(fileName));

        if (!fileName.isEmpty()) {
            ed->setHighlights(fileName);
            if(saveAsCodec(fileName, ed))
                setProject();
        }
    } catch(...) {
    }
}

void MainWindow::saveFileByTabIndex(int tab)
{
    try {
        QString fileName = editorTabs->tabToolTip(tab);

        this->editorTabs->setTabText(tab,shortFileName(fileName));
        if (!fileName.isEmpty()) {
            saveAsCodec(fileName, getEditor(tab));
        }
    } catch(...) {
    }
}

QString MainWindow::saveAsFile(const QString &path)
{
    QString fileName = path;
    try {
        int n = this->editorTabs->currentIndex();

        if (fileName.isEmpty())
            fileName = QFileDialog::getSaveFileName(this,
                tr("Save As File"), lastDirectory+"/"+this->editorTabs->tabText(n), programName + " Files (*.spin)");

        if (fileName.isEmpty()) {
            return QString();
        }
        lastDirectory = filePathName(fileName);

        this->editorTabs->setTabText(n,shortFileName(fileName));
        editorTabs->setTabToolTip(n,fileName);

        if (!fileName.isEmpty()) {
            getEditor(n)->setHighlights(fileName);
            if(saveAsCodec(fileName, getEditor(n)))
                setProject();
        }
    } catch(...) {
        return QString();
    }
    return fileName;
}

void MainWindow::fileChanged()
{
    if(fileChangeDisable)
        return;
    int index = editorTabs->currentIndex();
    QString name = editorTabs->tabText(index);
    QString fileName = editorTabs->tabToolTip(index);
    if(!QFile::exists(fileName))
        return;
    QFile file(fileName);
    if(file.open(QFile::ReadOnly))
    {
        QString curt = getEditor(index)->toPlainText();
        QString text; // = file.readAll();
        QTextStream in(&file);
        if(this->isFileUTF16(&file)) {
            in.setCodec("UTF-16");
        }
        else {
            in.setCodec("UTF-8");
        }
        text = in.readAll();
        file.close();

        if(text == curt) {
            if(name.at(name.length()-1) == '*')
                editorTabs->setTabText(index, this->shortFileName(fileName));
            return;
        }
    }
    if(name.at(name.length()-1) != '*') {
        name += tr(" *");
        editorTabs->setTabText(index, name);
    }
}

void MainWindow::setCurrentFile(const QString &fileName)
{
    QStringList files = settings->value(recentFilesKey).toStringList();
    files.removeAll(fileName);
    files.prepend(fileName);
    while (files.size() > MaxRecentFiles)
        files.removeLast();

    settings->setValue(recentFilesKey, files);

    foreach (QWidget *widget, QApplication::topLevelWidgets()) {
        MainWindow *mainWin = qobject_cast<MainWindow *>(widget);
        if (mainWin)
            mainWin->updateRecentFileActions();
    }
}

void MainWindow::updateRecentFileActions()
{
    QStringList files = settings->value(recentFilesKey).toStringList();

    int numRecentFiles = qMin(files.size(), (int)MaxRecentFiles);

    for (int i = 0; i < numRecentFiles; ++i) {
        QString estr = files.at(i);
        if(estr.length() == 0)
            continue;
        //QString filename = QFileInfo(projects[i]).fileName();
        QString text = tr("&%1 %2").arg(i + 1).arg(estr);
        recentFileActs[i]->setText(text);
        recentFileActs[i]->setData(estr);
        recentFileActs[i]->setVisible(true);
    }
    for (int j = numRecentFiles; j < MaxRecentFiles; ++j)
        recentFileActs[j]->setVisible(false);

    separatorFileAct->setVisible(numRecentFiles > 0);
}

void MainWindow::openRecentFile()
{
    QAction *action = qobject_cast<QAction *>(sender());
    if (action)
        openFile(action->data().toString());
}

void MainWindow::printFile()
{
}

void MainWindow::setProject()
{
    int index = editorTabs->currentIndex();
    if(index < 0)
        return;

    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

    QString fileName = editorTabs->tabToolTip(index);
    setCurrentFile(fileName);

    // Function setHighlights() only needs to be called once in setEditor().
    // Calling it again causes performance issues. Don't do it.
    // getEditor(index)->setHighlights(fileName);

    /* this should be changed to editor->clearHighlight() ...
     * or something whenever background coloring is used.
     */
    emit highlightCurrentLine(QColor());

    setWindowTitle(programName +" "+fileName);
    sizeLabel->setText("");
    msgLabel->setText("");

    //if(fileName.length() != 0)
    // it's ok for fileName to be zero length as in the case of "Untitled"

    QString text = getEditor(index)->toPlainText();
    updateProjectTree(fileName,text);
    if(leftSplit->isVisible()) {
        updateReferenceTree(fileName,text);
    }

    QApplication::processEvents();
    QApplication::restoreOverrideCursor();
}

void MainWindow::showBrowser()
{
    if(leftSplit->isVisible()) {
        if(referenceModel) {
            delete referenceModel;
            referenceModel = NULL;
        }
        leftSplit->hide();
    }
    else {
        QString text;
        QString fileName;
        if(!projectModel || !referenceModel) {
            QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
            int index = editorTabs->currentIndex();
            text = getEditor(index)->toPlainText();
            fileName = editorTabs->tabToolTip(index);
        }
        if(!referenceModel)
            updateReferenceTree(fileName,text);
        leftSplit->show();
        QApplication::processEvents();
        QApplication::restoreOverrideCursor();
    }
}

void MainWindow::fontDialog()
{
    bool ok = true;

    QFontDialog fd(this);
    QFont font;
    Editor *editor = getEditor(editorTabs->currentIndex());
    if(editor) {
        QFont edfont = editor->font();
        qDebug() << "Editor Font" << editor->font().family();
        font = fd.getFont(&ok, edfont, this);
    }
    else {
        font = fd.getFont(&ok, editorFont, this);
    }
    qDebug() << "New Editor Font" << font.family();

    if(ok) {
        for(int n = editorTabs->count()-1; n >= 0; n--) {
            Editor *ed = getEditor(n);
            ed->setFont(font);
            QString fs = QString("font: %1pt \"%2\";").arg(font.pointSize()).arg(font.family());
            ed->setStyleSheet(fs);
        }
        editorFont = font;
        qDebug() << "Ok, Editor Font" << editorFont.family();
    }
}

void MainWindow::fontBigger()
{
    Editor *editor = getEditor(editorTabs->currentIndex());
    if(editor) {
        QFont font = editor->font();
        int size = font.pointSize();
        QString fname = font.family();
        // Parallax font is buggy. 26, 36, and 48 are bad.
        if(fname.compare("Parallax", Qt::CaseInsensitive) == 0) {
            int fsizes[] = { 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 28, 72 };
            int flast = (sizeof(fsizes)/4)-1;
            if(size >= fsizes[0] && size < fsizes[flast]) {
                for(int n = 0; n <= flast-1; n++) {
                    if(size == fsizes[n]) {
                        font.setPointSize(fsizes[n+1]);
                        break;
                    }
                }
            }
        }
        else {
            size = size*10/8;
            if(size < 90)
                font.setPointSize(size);
        }
        for(int n = editorTabs->count()-1; n >= 0; n--) {
            Editor *ed = getEditor(n);
            ed->setFont(font);
            QString fs = QString("font: %1pt \"%2\";").arg(font.pointSize()).arg(font.family());
            ed->setStyleSheet(fs);

        }
        editorFont = font;
        QApplication::processEvents();
    }
}

void MainWindow::fontSmaller()
{
    Editor *editor = getEditor(editorTabs->currentIndex());
    if(editor) {
        QFont font = editor->font();
        int size = font.pointSize();
        QString fname = font.family();
        // Parallax font is buggy. 26, 36, and 48 are bad.
        if(fname.compare("Parallax", Qt::CaseInsensitive) == 0) {
            int fsizes[] = { 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 28, 72 };
            int flast = (sizeof(fsizes)/4)-1;
            if(size > fsizes[0] && size <= fsizes[flast]) {
                for(int n = 1; n <= flast; n++) {
                    if(size == fsizes[n]) {
                        font.setPointSize(fsizes[n-1]);
                        break;
                    }
                }
            }
        }
        else {
            size = size*8/10;
            if(size > 3)
                font.setPointSize(size);
        }
        for(int n = editorTabs->count()-1; n >= 0; n--) {
            Editor *ed = getEditor(n);
            ed->setFont(font);
            QString fs = QString("font: %1pt \"%2\";").arg(font.pointSize()).arg(font.family());
            ed->setStyleSheet(fs);
        }
        editorFont = font;
        QApplication::processEvents();
    }
}

void MainWindow::hardware()
{
}

void MainWindow::properties()
{
    propDialog->showProperties(this->lastDirectory);
}
void MainWindow::propertiesAccepted()
{
    /* set properties */
    getApplicationSettings(false);
    initBoardTypes();
}

void MainWindow::setCurrentPort(int index)
{
    QString portName = cbPort->itemText(index);
    term->setPortName(portName);
    cbPort->setCurrentIndex(index);
    if(portName.length()) {
        portListener->init(portName, term->getBaud());  // signals get hooked up internally
#ifdef Q_OS_WIN
        // do this so that the handle will change for windows
        if(portListener->isOpen()) {
            portListener->close();
            portListener->open();
        }
#endif
    }
}

void MainWindow::checkAndSaveFiles()
{
    if(projectModel == NULL)
        return;
    QString title = projectModel->getTreeName();
    QString modTitle = title + " *";
    for(int tab = editorTabs->count()-1; tab > -1; tab--)
    {
        QString tabName = editorTabs->tabText(tab);
        if(tabName == modTitle)
        {
            saveFileByTabIndex(tab);
            editorTabs->setTabText(tab,title);
        }
    }

    int len = projectModel->rowCount();
    for(int n = 0; n < len; n++)
    {
        QModelIndex root = projectModel->index(n,0);
        QVariant vs = projectModel->data(root, Qt::DisplayRole);
        if(!vs.canConvert(QVariant::String))
            continue;
        QString name = vs.toString();
        QString modName = name + " *";
        for(int tab = editorTabs->count()-1; tab > -1; tab--)
        {
            QString tabName = editorTabs->tabText(tab);
            if(tabName == modName)
            {
                saveFileByTabIndex(tab);
                editorTabs->setTabText(tab,name);
            }
        }
    }
}

void MainWindow::highlightFileLine(QString file, int line)
{
    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

    QString name;