utils/themeeditor/gui/skindocument.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2010 Robert Bieber
  11  *
  12  * This program is free software;  can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your optiyouon) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "skindocument.h"
  23
  24 #include <QFile>
  25 #include <QSettings>
  26 #include <QColor>
  27 #include <QMessageBox>
  28 #include <QFileDialog>
  29
  30 #include <iostream>
  31
  32 #include <QDebug>
  33
  34 const int SkinDocument::updateInterval = 500;
  35
  36 SkinDocument::SkinDocument(QLabel* statusLabel, ProjectModel* project,
  37                            DeviceState* device, QWidget *parent)
  38                                :TabContent(parent), statusLabel(statusLabel),
  39                                project(project), device(device)
  40 {
  41     setupUI();
  42
  43     titleText = "Untitled";
  44     fileName = "";
  45     saved = "";
  46     parseStatus = tr("Empty document");
  47     blockUpdate = false;
  48     currentLine = -1;
  49 }
  50
  51 SkinDocument::SkinDocument(QLabel* statusLabel, QString file,
  52                            ProjectModel* project, DeviceState* device,
  53                            QWidget *parent)
  54                                :TabContent(parent), fileName(file),
  55                                statusLabel(statusLabel), project(project),
  56                                device(device)
  57 {
  58     setupUI();
  59     blockUpdate = false;
  60
  61     /* Loading the file */
  62     if(QFile::exists(fileName))
  63     {
  64         QFile fin(fileName);
  65         fin.open(QFile::ReadOnly);
  66         editor->document()->setPlainText(QString(fin.readAll()));
  67         saved = editor->document()->toPlainText();
  68         editor->setTextCursor(QTextCursor(editor->document()->begin()));
  69         fin.close();
  70     }
  71
  72     /* Setting the title */
  73     QStringList decomposed = fileName.split('/');
  74     titleText = decomposed.last();
  75
  76     lastUpdate = QTime::currentTime();
  77 }
  78
  79 SkinDocument::~SkinDocument()
  80 {
  81     highlighter->deleteLater();
  82     model->deleteLater();
  83 }
  84
  85 void SkinDocument::connectPrefs(PreferencesDialog* prefs)
  86 {
  87     QObject::connect(prefs, SIGNAL(accepted()),
  88                      this, SLOT(settingsChanged()));
  89     QObject::connect(prefs, SIGNAL(accepted()),
  90                      highlighter, SLOT(loadSettings()));
  91 }
  92
  93 bool SkinDocument::requestClose()
  94 {
  95     /* Storing the response in blockUpdate will also block updates to the
  96        status bar if the tab is being closed */
  97     if(editor->document()->toPlainText() != saved)
  98     {
  99         /* Spawning the "Are you sure?" dialog */
 100         QMessageBox confirm(this);
 101         confirm.setWindowTitle(tr("Confirm Close"));
 102         confirm.setText(titleText + tr(" has been modified."));
 103         confirm.setInformativeText(tr("Do you want to save your changes?"));
 104         confirm.setStandardButtons(QMessageBox::Save | QMessageBox::Discard
 105                                    | QMessageBox::Cancel);
 106         confirm.setDefaultButton(QMessageBox::Save);
 107         int confirmation = confirm.exec();
 108
 109         switch(confirmation)
 110         {
 111         case QMessageBox::Save:
 112             save();
 113             /* After calling save, make sure the user actually went through */
 114             if(editor->document()->toPlainText() != saved)
 115                 blockUpdate = false;
 116             else
 117                 blockUpdate = true;
 118             break;
 119
 120         case QMessageBox::Discard:
 121             blockUpdate = true;
 122             break;
 123
 124         case QMessageBox::Cancel:
 125             blockUpdate = false;
 126             break;
 127         }
 128     }
 129     else
 130         blockUpdate = true;
 131
 132     return blockUpdate;
 133 }
 134
 135 void SkinDocument::setupUI()
 136 {
 137     /* Setting up the text edit */
 138     layout = new QHBoxLayout;
 139     editor = new CodeEditor(this);
 140     editor->setLineWrapMode(QPlainTextEdit::NoWrap);
 141     layout->addWidget(editor);
 142
 143     setLayout(layout);
 144
 145     /* Attaching the syntax highlighter */
 146     highlighter = new SkinHighlighter(editor->document());
 147
 148     /* Setting up the model */
 149     model = new ParseTreeModel("");
 150
 151     /* Connecting the editor's signal */
 152     QObject::connect(editor, SIGNAL(textChanged()),
 153                      this, SLOT(codeChanged()));
 154     QObject::connect(editor, SIGNAL(cursorPositionChanged()),
 155                      this, SLOT(cursorChanged()));
 156
 157     /* Connecting to device setting changes */
 158     QObject::connect(device, SIGNAL(settingsChanged()),
 159                      this, SLOT(deviceChanged()));
 160
 161     /* Attaching the find/replace dialog */
 162     findReplace = new FindReplaceDialog(this);
 163     findReplace->setModal(false);
 164     findReplace->setTextEdit(editor);
 165     findReplace->hide();
 166
 167     settingsChanged();
 168
 169     /* Setting up a timer to check for updates */
 170     checkUpdate.setInterval(500);
 171     QObject::connect(&checkUpdate, SIGNAL(timeout()),
 172                      this, SLOT(codeChanged()));
 173 }
 174
 175 void SkinDocument::settingsChanged()
 176 {
 177     /* Setting the editor colors */
 178     QSettings settings;
 179     settings.beginGroup("SkinDocument");
 180
 181     QColor fg = settings.value("fgColor", Qt::black).value<QColor>();
 182     QColor bg = settings.value("bgColor", Qt::white).value<QColor>();
 183     QPalette palette;
 184     palette.setColor(QPalette::All, QPalette::Base, bg);
 185     palette.setColor(QPalette::All, QPalette::Text, fg);
 186     editor->setPalette(palette);
 187
 188     QColor highlight = settings.value("errorColor", Qt::red).value<QColor>();
 189     editor->setErrorColor(highlight);
 190
 191     /* Setting the font */
 192     QFont def("Monospace");
 193     def.setStyleHint(QFont::TypeWriter);
 194     QFont family = settings.value("fontFamily", def).value<QFont>();
 195     family.setPointSize(settings.value("fontSize", 12).toInt());
 196     editor->setFont(family);
 197
 198     editor->repaint();
 199
 200     settings.endGroup();
 201
 202 }
 203
 204 void SkinDocument::cursorChanged()
 205 {
 206     if(editor->isError(editor->textCursor().blockNumber() + 1))
 207     {
 208         QTextCursor line = editor->textCursor();
 209         line.movePosition(QTextCursor::StartOfLine);
 210         line.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);
 211         skin_parse(line.selectedText().toAscii());
 212         if(skin_error_line() > 0)
 213             parseStatus = tr("Error on line ") +
 214                           QString::number(line.blockNumber() + 1)
 215                           + tr(", column ") + QString::number(skin_error_col())
 216                           + tr(": ") +
 217                           skin_error_message();
 218         statusLabel->setText(parseStatus);
 219     }
 220     else if(editor->hasErrors())
 221     {
 222         parseStatus = tr("Errors in document");
 223         statusLabel->setText(parseStatus);
 224     }
 225     else if(editor->textCursor().blockNumber() != currentLine)
 226     {
 227         currentLine = editor->textCursor().blockNumber();
 228         emit lineChanged(editor->textCursor().blockNumber() + 1);
 229     }
 230
 231 }
 232
 233 void SkinDocument::codeChanged()
 234 {
 235     if(blockUpdate)
 236         return;
 237
 238     if(editor->document()->isEmpty())
 239     {
 240         parseStatus = tr("Empty document");
 241         statusLabel->setText(parseStatus);
 242         return;
 243     }
 244
 245     editor->clearErrors();
 246     parseStatus = model->changeTree(editor->document()->
 247                                     toPlainText().toAscii());
 248     if(skin_error_line() > 0)
 249         parseStatus = tr("Errors in document");
 250     statusLabel->setText(parseStatus);
 251
 252     /* Highlighting if an error was found */
 253     if(skin_error_line() > 0)
 254     {
 255         editor->addError(skin_error_line());
 256
 257         /* Now we're going to attempt parsing again at each line, until we find
 258            one that won't error out*/
 259         QTextDocument doc(editor->document()->toPlainText());
 260         int base = 0;
 261         while(skin_error_line() > 0 && !doc.isEmpty())
 262         {
 263             QTextCursor rest(&doc);
 264
 265             for(int i = 0; i < skin_error_line(); i++)
 266                 rest.movePosition(QTextCursor::NextBlock,
 267                                   QTextCursor::KeepAnchor);
 268             if(skin_error_line() == doc.blockCount())
 269                 rest.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
 270
 271             rest.removeSelectedText();
 272             base += skin_error_line();
 273
 274             skin_parse(doc.toPlainText().toAscii());
 275
 276             if(skin_error_line() > 0)
 277                 editor->addError(base + skin_error_line());
 278
 279         }
 280     }
 281
 282     if(editor->document()->toPlainText() != saved)
 283         emit titleChanged(titleText + QChar('*'));
 284     else
 285         emit titleChanged(titleText);
 286
 287     if(lastUpdate.msecsTo(QTime::currentTime()) >= updateInterval)
 288     {
 289         model->render(project, device, &fileName);
 290         checkUpdate.stop();
 291         lastUpdate = QTime::currentTime();
 292     }
 293     else
 294     {
 295         checkUpdate.start();
 296     }
 297     cursorChanged();
 298
 299 }
 300
 301 void SkinDocument::save()
 302 {
 303     QFile fout(fileName);
 304
 305     if(!fout.exists())
 306     {
 307         saveAs();
 308         return;
 309     }
 310
 311     fout.open(QFile::WriteOnly);
 312     fout.write(editor->document()->toPlainText().toAscii());
 313     fout.close();
 314
 315     saved = editor->document()->toPlainText();
 316     QStringList decompose = fileName.split('/');
 317     titleText = decompose.last();
 318     emit titleChanged(titleText);
 319
 320     scene();
 321
 322 }
 323
 324 void SkinDocument::saveAs()
 325 {
 326     /* Determining the directory to open */
 327     QString directory = fileName;
 328
 329     QSettings settings;
 330     settings.beginGroup("SkinDocument");
 331     if(directory == "")
 332         directory = settings.value("defaultDirectory", "").toString();
 333
 334     fileName = QFileDialog::getSaveFileName(this, tr("Save Document"),
 335                                             directory, fileFilter());
 336     directory = fileName;
 337     if(fileName == "")
 338         return;
 339
 340     directory.chop(fileName.length() - fileName.lastIndexOf('/') - 1);
 341     settings.setValue("defaultDirectory", directory);
 342     settings.endGroup();
 343
 344     QFile fout(fileName);
 345     fout.open(QFile::WriteOnly);
 346     fout.write(editor->document()->toPlainText().toAscii());
 347     fout.close();
 348
 349     saved = editor->document()->toPlainText();
 350     QStringList decompose = fileName.split('/');
 351     titleText = decompose[decompose.count() - 1];
 352     emit titleChanged(titleText);
 353
 354     scene();
 355
 356 }
 357
 358 QString SkinDocument::findSetting(QString key, QString fallback)
 359 {
 360     if(!project)
 361         return fallback;
 362     else
 363         return project->getSetting(key, fallback);
 364 }