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