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