utils/themeeditor/editorwindow.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; you 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 option) 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 "editorwindow.h"
  23 #include "projectmodel.h"
  24 #include "ui_editorwindow.h"
  25
  26 #include <QDesktopWidget>
  27 #include <QFileSystemModel>
  28 #include <QSettings>
  29 #include <QFileDialog>
  30
  31 EditorWindow::EditorWindow(QWidget *parent) :
  32     QMainWindow(parent),
  33     ui(new Ui::EditorWindow)
  34 {
  35     ui->setupUi(this);
  36     prefs = new PreferencesDialog(this);
  37     project = 0;
  38     loadSettings();
  39     setupUI();
  40     setupMenus();
  41 }
  42
  43 void EditorWindow::loadTabFromSkinFile(QString fileName)
  44 {
  45     /* Checking to see if the file is already open */
  46     for(int i = 0; i < ui->editorTabs->count(); i++)
  47     {
  48         TabContent* current = dynamic_cast<TabContent*>
  49                                 (ui->editorTabs->widget(i));
  50         if(current->file() == fileName)
  51         {
  52             ui->editorTabs->setCurrentIndex(i);
  53             return;
  54         }
  55     }
  56
  57     /* Adding a new document*/
  58     SkinDocument* doc = new SkinDocument(parseStatus, fileName);
  59     addTab(doc);
  60     ui->editorTabs->setCurrentWidget(doc);
  61
  62 }
  63
  64 void EditorWindow::loadConfigTab(ConfigDocument* doc)
  65 {
  66     for(int i = 0; i < ui->editorTabs->count(); i++)
  67     {
  68         TabContent* current = dynamic_cast<TabContent*>
  69                               (ui->editorTabs->widget(i));
  70         if(current->file() == doc->file())
  71         {
  72             ui->editorTabs->setCurrentIndex(i);
  73             doc->deleteLater();
  74             return;
  75         }
  76     }
  77
  78     addTab(doc);
  79     ui->editorTabs->setCurrentWidget(doc);
  80
  81     QObject::connect(doc, SIGNAL(titleChanged(QString)),
  82                      this, SLOT(tabTitleChanged(QString)));
  83 }
  84
  85 void EditorWindow::loadSettings()
  86 {
  87
  88     QSettings settings;
  89
  90     /* Main Window location */
  91     settings.beginGroup("EditorWindow");
  92     QSize size = settings.value("size").toSize();
  93     QPoint pos = settings.value("position").toPoint();
  94     QByteArray state = settings.value("state").toByteArray();
  95     settings.endGroup();
  96
  97     if(!(size.isNull() || pos.isNull() || state.isNull()))
  98     {
  99         resize(size);
 100         move(pos);
 101         restoreState(state);
 102     }
 103
 104 }
 105
 106 void EditorWindow::saveSettings()
 107 {
 108
 109     QSettings settings;
 110
 111     /* Saving window and panel positions */
 112     settings.beginGroup("EditorWindow");
 113     settings.setValue("position", pos());
 114     settings.setValue("size", size());
 115     settings.setValue("state", saveState());
 116     settings.endGroup();
 117 }
 118
 119 void EditorWindow::setupUI()
 120 {
 121     /* Connecting the tab bar signals */
 122     QObject::connect(ui->editorTabs, SIGNAL(currentChanged(int)),
 123                      this, SLOT(shiftTab(int)));
 124     QObject::connect(ui->editorTabs, SIGNAL(tabCloseRequested(int)),
 125                      this, SLOT(closeTab(int)));
 126
 127     /* Connecting the code gen button */
 128     QObject::connect(ui->fromTree, SIGNAL(pressed()),
 129                      this, SLOT(updateCurrent()));
 130
 131     /* Connecting the preferences dialog */
 132     QObject::connect(ui->actionPreferences, SIGNAL(triggered()),
 133                      prefs, SLOT(exec()));
 134
 135     /* Setting up the parse status label */
 136     parseStatus = new QLabel(this);
 137     ui->statusbar->addPermanentWidget(parseStatus);
 138
 139     parseTreeSelection = 0;
 140 }
 141
 142 void EditorWindow::setupMenus()
 143 {
 144     /* Connecting panel show actions */
 145     QObject::connect(ui->actionFile_Panel, SIGNAL(triggered()),
 146                      this, SLOT(showPanel()));
 147     QObject::connect(ui->actionDisplay_Panel, SIGNAL(triggered()),
 148                      this, SLOT(showPanel()));
 149     QObject::connect(ui->actionPreview_Panel, SIGNAL(triggered()),
 150                      this, SLOT(showPanel()));
 151
 152     /* Connecting the document management actions */
 153     QObject::connect(ui->actionNew_Document, SIGNAL(triggered()),
 154                      this, SLOT(newTab()));
 155     QObject::connect(ui->actionToolbarNew, SIGNAL(triggered()),
 156                      this, SLOT(newTab()));
 157
 158     QObject::connect(ui->actionClose_Document, SIGNAL(triggered()),
 159                      this, SLOT(closeCurrent()));
 160
 161     QObject::connect(ui->actionSave_Document, SIGNAL(triggered()),
 162                      this, SLOT(saveCurrent()));
 163     QObject::connect(ui->actionSave_Document_As, SIGNAL(triggered()),
 164                      this, SLOT(saveCurrentAs()));
 165     QObject::connect(ui->actionToolbarSave, SIGNAL(triggered()),
 166                      this, SLOT(saveCurrent()));
 167
 168     QObject::connect(ui->actionOpen_Document, SIGNAL(triggered()),
 169                      this, SLOT(openFile()));
 170     QObject::connect(ui->actionToolbarOpen, SIGNAL(triggered()),
 171                      this, SLOT(openFile()));
 172
 173     QObject::connect(ui->actionOpen_Project, SIGNAL(triggered()),
 174                      this, SLOT(openProject()));
 175 }
 176
 177 void EditorWindow::addTab(TabContent *doc)
 178 {
 179     ui->editorTabs->addTab(doc, doc->title());
 180
 181     /* Connecting to title change events */
 182     QObject::connect(doc, SIGNAL(titleChanged(QString)),
 183                      this, SLOT(tabTitleChanged(QString)));
 184     QObject::connect(doc, SIGNAL(lineChanged(int)),
 185                      this, SLOT(lineChanged(int)));
 186
 187     /* Connecting to settings change events */
 188     if(doc->type() == TabContent::Skin)
 189         dynamic_cast<SkinDocument*>(doc)->connectPrefs(prefs);
 190 }
 191
 192
 193 void EditorWindow::newTab()
 194 {
 195     SkinDocument* doc = new SkinDocument(parseStatus);
 196     addTab(doc);
 197     ui->editorTabs->setCurrentWidget(doc);
 198 }
 199
 200 void EditorWindow::shiftTab(int index)
 201 {
 202     TabContent* widget = dynamic_cast<TabContent*>
 203                          (ui->editorTabs->currentWidget());
 204     if(index < 0)
 205     {
 206         ui->parseTree->setModel(0);
 207         ui->actionSave_Document->setEnabled(false);
 208         ui->actionSave_Document_As->setEnabled(false);
 209         ui->actionClose_Document->setEnabled(false);
 210         ui->actionToolbarSave->setEnabled(false);
 211         ui->fromTree->setEnabled(false);
 212     }
 213     else if(widget->type() == TabContent::Config)
 214     {
 215         ui->actionSave_Document->setEnabled(true);
 216         ui->actionSave_Document_As->setEnabled(true);
 217         ui->actionClose_Document->setEnabled(true);
 218         ui->actionToolbarSave->setEnabled(true);
 219     }
 220     else
 221     {
 222         /* Syncing the tree view and the status bar */
 223         SkinDocument* doc = dynamic_cast<SkinDocument*>(widget);
 224         ui->parseTree->setModel(doc->getModel());
 225         parseStatus->setText(doc->getStatus());
 226
 227         ui->actionSave_Document->setEnabled(true);
 228         ui->actionSave_Document_As->setEnabled(true);
 229         ui->actionClose_Document->setEnabled(true);
 230         ui->actionToolbarSave->setEnabled(true);
 231         ui->fromTree->setEnabled(true);
 232
 233         sizeColumns();
 234
 235     }
 236 }
 237
 238 bool EditorWindow::closeTab(int index)
 239 {
 240     TabContent* widget = dynamic_cast<TabContent*>
 241                            (ui->editorTabs->widget(index));
 242     if(widget->requestClose())
 243     {
 244         ui->editorTabs->removeTab(index);
 245         widget->deleteLater();
 246         return true;
 247     }
 248
 249     return false;
 250 }
 251
 252 void EditorWindow::closeCurrent()
 253 {
 254     closeTab(ui->editorTabs->currentIndex());
 255 }
 256
 257 void EditorWindow::saveCurrent()
 258 {
 259     if(ui->editorTabs->currentIndex() >= 0)
 260         dynamic_cast<TabContent*>(ui->editorTabs->currentWidget())->save();
 261 }
 262
 263 void EditorWindow::saveCurrentAs()
 264 {
 265     if(ui->editorTabs->currentIndex() >= 0)
 266         dynamic_cast<TabContent*>(ui->editorTabs->currentWidget())->saveAs();
 267 }
 268
 269 void EditorWindow::openFile()
 270 {
 271     QStringList fileNames;
 272     QSettings settings;
 273
 274     settings.beginGroup("SkinDocument");
 275     QString directory = settings.value("defaultDirectory", "").toString();
 276     fileNames = QFileDialog::getOpenFileNames(this, tr("Open Files"), directory,
 277                                               SkinDocument::fileFilter());
 278
 279     for(int i = 0; i < fileNames.count(); i++)
 280     {
 281         if(!QFile::exists(fileNames[i]))
 282             continue;
 283
 284         QString current = fileNames[i];
 285
 286         loadTabFromSkinFile(current);
 287
 288         /* And setting the new default directory */
 289         current.chop(current.length() - current.lastIndexOf('/') - 1);
 290         settings.setValue("defaultDirectory", current);
 291
 292     }
 293
 294     settings.endGroup();
 295 }
 296
 297 void EditorWindow::openProject()
 298 {
 299     QString fileName;
 300     QSettings settings;
 301
 302     settings.beginGroup("ProjectModel");
 303     QString directory = settings.value("defaultDirectory", "").toString();
 304     fileName = QFileDialog::getOpenFileName(this, tr("Open Project"), directory,
 305                                             ProjectModel::fileFilter());
 306
 307     if(QFile::exists(fileName))
 308     {
 309
 310         if(project)
 311             delete project;
 312
 313         project = new ProjectModel(fileName, this);
 314         ui->projectTree->setModel(project);
 315
 316         QObject::connect(ui->projectTree, SIGNAL(activated(QModelIndex)),
 317                          project, SLOT(activated(QModelIndex)));
 318
 319         fileName.chop(fileName.length() - fileName.lastIndexOf('/') - 1);
 320         settings.setValue("defaultDirectory", fileName);
 321
 322     }
 323
 324     settings.endGroup();
 325
 326 }
 327
 328 void EditorWindow::configFileChanged(QString configFile)
 329 {
 330
 331     QSettings settings;
 332
 333     settings.beginGroup("ProjectModel");
 334
 335     if(QFile::exists(configFile))
 336     {
 337
 338         if(project)
 339             delete project;
 340
 341         project = new ProjectModel(configFile, this);
 342         ui->projectTree->setModel(project);
 343
 344         QObject::connect(ui->projectTree, SIGNAL(activated(QModelIndex)),
 345                          project, SLOT(activated(QModelIndex)));
 346
 347         configFile.chop(configFile.length() - configFile.lastIndexOf('/') - 1);
 348         settings.setValue("defaultDirectory", configFile);
 349
 350     }
 351
 352     settings.endGroup();
 353
 354 }
 355
 356 void EditorWindow::tabTitleChanged(QString title)
 357 {
 358     TabContent* sender = dynamic_cast<TabContent*>(QObject::sender());
 359     ui->editorTabs->setTabText(ui->editorTabs->indexOf(sender), title);
 360 }
 361
 362 void EditorWindow::showPanel()
 363 {
 364     if(sender() == ui->actionFile_Panel)
 365         ui->projectDock->setVisible(true);
 366     if(sender() == ui->actionPreview_Panel)
 367         ui->skinPreviewDock->setVisible(true);
 368     if(sender() == ui->actionDisplay_Panel)
 369         ui->parseTreeDock->setVisible(true);
 370 }
 371
 372 void EditorWindow::closeEvent(QCloseEvent* event)
 373 {
 374
 375     saveSettings();
 376
 377     /* Closing all the tabs */
 378     for(int i = 0; i < ui->editorTabs->count(); i++)
 379     {
 380         if(!dynamic_cast<TabContent*>
 381            (ui->editorTabs->widget(i))->requestClose())
 382         {
 383             event->ignore();
 384             return;
 385         }
 386     }
 387
 388     event->accept();
 389 }
 390
 391 void EditorWindow::updateCurrent()
 392 {
 393     if(ui->editorTabs->currentIndex() < 0)
 394         return;
 395
 396     dynamic_cast<SkinDocument*>
 397             (ui->editorTabs->currentWidget())->genCode();
 398 }
 399
 400 void EditorWindow::lineChanged(int line)
 401 {
 402     ui->parseTree->collapseAll();
 403     if(parseTreeSelection)
 404         parseTreeSelection->deleteLater();
 405     ParseTreeModel* model = dynamic_cast<ParseTreeModel*>
 406                             (ui->parseTree->model());
 407     parseTreeSelection = new QItemSelectionModel(model);
 408     expandLine(model, QModelIndex(), line);
 409     sizeColumns();
 410     ui->parseTree->setSelectionModel(parseTreeSelection);
 411
 412 }
 413
 414 void EditorWindow::expandLine(ParseTreeModel* model, QModelIndex parent,
 415                               int line)
 416 {
 417     for(int i = 0; i < model->rowCount(parent); i++)
 418     {
 419         QModelIndex dataType = model->index(i, ParseTreeModel::typeColumn,
 420                                             parent);
 421         QModelIndex dataVal = model->index(i, ParseTreeModel::valueColumn,
 422                                            parent);
 423         QModelIndex data = model->index(i, ParseTreeModel::lineColumn, parent);
 424         QModelIndex recurse = model->index(i, 0, parent);
 425
 426         expandLine(model, recurse, line);
 427
 428         if(model->data(data, Qt::DisplayRole) == line)
 429         {
 430             ui->parseTree->expand(parent);
 431             ui->parseTree->expand(data);
 432             ui->parseTree->scrollTo(parent, QAbstractItemView::PositionAtTop);
 433
 434             parseTreeSelection->select(data, QItemSelectionModel::Select);
 435             parseTreeSelection->select(dataType, QItemSelectionModel::Select);
 436             parseTreeSelection->select(dataVal, QItemSelectionModel::Select);
 437         }
 438
 439     }
 440 }
 441
 442 void EditorWindow::sizeColumns()
 443 {
 444     /* Setting the column widths */
 445     ui->parseTree->resizeColumnToContents(ParseTreeModel::lineColumn);
 446     ui->parseTree->resizeColumnToContents(ParseTreeModel::typeColumn);
 447     ui->parseTree->resizeColumnToContents(ParseTreeModel::valueColumn);
 448 }
 449
 450 EditorWindow::~EditorWindow()
 451 {
 452     delete ui;
 453     delete prefs;
 454     if(project)
 455         delete project;
 456 }