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 #include "rbfontcache.h"
  26 #include "rbtextcache.h"
  27 #include "newprojectdialog.h"
  28 #include "projectexporter.h"
  29
  30 #include <QDesktopWidget>
  31 #include <QFileSystemModel>
  32 #include <QSettings>
  33 #include <QFileDialog>
  34 #include <QMessageBox>
  35 #include <QGraphicsScene>
  36 #include <QDir>
  37 #include <QFile>
  38
  39 const int EditorWindow::numRecent = 5;
  40
  41 EditorWindow::EditorWindow(QWidget *parent) :
  42     QMainWindow(parent), ui(new Ui::EditorWindow), parseTreeSelection(0)
  43 {
  44     ui->setupUi(this);
  45     prefs = new PreferencesDialog(this);
  46     project = 0;
  47     setupUI();
  48     loadSettings();
  49     setupMenus();
  50 }
  51
  52
  53 EditorWindow::~EditorWindow()
  54 {
  55     delete ui;
  56     delete prefs;
  57     if(project)
  58         delete project;
  59     delete deviceConfig;
  60     delete deviceDock;
  61     delete timer;
  62     delete timerDock;
  63
  64     RBFontCache::clearCache();
  65     RBTextCache::clearCache();
  66 }
  67
  68 void EditorWindow::loadTabFromSkinFile(QString fileName)
  69 {
  70     docToTop(fileName);
  71
  72     /* Checking to see if the file is already open */
  73     for(int i = 0; i < ui->editorTabs->count(); i++)
  74     {
  75         TabContent* current = dynamic_cast<TabContent*>
  76                                 (ui->editorTabs->widget(i));
  77         if(current->file() == fileName)
  78         {
  79             ui->editorTabs->setCurrentIndex(i);
  80             return;
  81         }
  82     }
  83
  84     /* Adding a new document*/
  85     SkinDocument* doc = new SkinDocument(parseStatus, fileName, project,
  86                                          deviceConfig);
  87     addTab(doc);
  88     ui->editorTabs->setCurrentWidget(doc);
  89
  90 }
  91
  92 void EditorWindow::loadConfigTab(ConfigDocument* doc)
  93 {
  94     for(int i = 0; i < ui->editorTabs->count(); i++)
  95     {
  96         TabContent* current = dynamic_cast<TabContent*>
  97                               (ui->editorTabs->widget(i));
  98         if(current->file() == doc->file())
  99         {
 100             ui->editorTabs->setCurrentIndex(i);
 101             doc->deleteLater();
 102             return;
 103         }
 104     }
 105
 106     addTab(doc);
 107     ui->editorTabs->setCurrentWidget(doc);
 108
 109     QObject::connect(doc, SIGNAL(titleChanged(QString)),
 110                      this, SLOT(tabTitleChanged(QString)));
 111 }
 112
 113 void  EditorWindow::loadSettings()
 114 {
 115
 116     QSettings settings;
 117
 118     /* Main Window location */
 119     settings.beginGroup("EditorWindow");
 120     QSize size = settings.value("size").toSize();
 121     QPoint pos = settings.value("position").toPoint();
 122     QByteArray state = settings.value("state").toByteArray();
 123
 124     /* Recent docs/projects */
 125     recentDocs = settings.value("recentDocs", QStringList()).toStringList();
 126     recentProjects = settings.value("recentProjects",
 127                                     QStringList()).toStringList();
 128
 129     settings.endGroup();
 130
 131     if(!(size.isNull() || pos.isNull() || state.isNull()))
 132     {
 133         resize(size);
 134         move(pos);
 135         restoreState(state);
 136     }
 137
 138 }
 139
 140 void EditorWindow::saveSettings()
 141 {
 142
 143     QSettings settings;
 144
 145     /* Saving window and panel positions */
 146     settings.beginGroup("EditorWindow");
 147     settings.setValue("position", pos());
 148     settings.setValue("size", size());
 149     settings.setValue("state", saveState());
 150
 151     /* Saving recent docs/projects */
 152     settings.setValue("recentDocs", recentDocs);
 153     settings.setValue("recentProjects", recentProjects);
 154
 155     settings.endGroup();
 156 }
 157
 158 void EditorWindow::setupUI()
 159 {
 160     /* Connecting the tab bar signals */
 161     QObject::connect(ui->editorTabs, SIGNAL(currentChanged(int)),
 162                      this, SLOT(shiftTab(int)));
 163     QObject::connect(ui->editorTabs, SIGNAL(tabCloseRequested(int)),
 164                      this, SLOT(closeTab(int)));
 165
 166     /* Connecting the code gen button */
 167     QObject::connect(ui->fromTree, SIGNAL(pressed()),
 168                      this, SLOT(updateCurrent()));
 169
 170     /* Connecting the preferences dialog */
 171     QObject::connect(ui->actionPreferences, SIGNAL(triggered()),
 172                      prefs, SLOT(exec()));
 173
 174     /* Setting up the parse status label */
 175     parseStatus = new QLabel(this);
 176     ui->statusbar->addPermanentWidget(parseStatus);
 177
 178     /* Setting the selection for parse tree highlighting initially NULL */
 179     parseTreeSelection = 0;
 180
 181     /* Adding the skin viewer */
 182     viewer = new SkinViewer(this);
 183     ui->skinPreviewLayout->addWidget(viewer);
 184
 185     /* Positioning the device settings dialog */
 186     deviceDock = new QDockWidget(tr("Device Configuration"), this);
 187     deviceConfig = new DeviceState(deviceDock);
 188
 189     deviceDock->setObjectName("deviceDock");
 190     deviceDock->setWidget(deviceConfig);
 191     deviceDock->setFloating(true);
 192     deviceDock->move(QPoint(x() + width() / 2, y() + height() / 2));
 193     deviceDock->hide();
 194
 195     /* Positioning the timer panel */
 196     timerDock = new QDockWidget(tr("Timer"), this);
 197     timer = new SkinTimer(deviceConfig, timerDock);
 198
 199     timerDock->setObjectName("timerDock");
 200     timerDock->setWidget(timer);
 201     timerDock->setFloating(true);
 202     timerDock->move(QPoint(x() + width() / 2, y() + height() / 2));
 203     timerDock->hide();
 204
 205     shiftTab(-1);
 206 }
 207
 208 void EditorWindow::setupMenus()
 209 {
 210     /* Adding actions to the toolbar */
 211     ui->toolBar->addAction(ui->actionNew_Document);
 212     ui->toolBar->addAction(ui->actionOpen_Document);
 213     ui->toolBar->addAction(ui->actionSave_Document);
 214     ui->toolBar->addAction(ui->actionSave_Document_As);
 215
 216     ui->toolBar->addSeparator();
 217     ui->toolBar->addAction(ui->actionUndo);
 218     ui->toolBar->addAction(ui->actionRedo);
 219
 220     ui->toolBar->addSeparator();
 221     ui->toolBar->addAction(ui->actionCut);
 222     ui->toolBar->addAction(ui->actionCopy);
 223     ui->toolBar->addAction(ui->actionPaste);
 224
 225     ui->toolBar->addSeparator();
 226     ui->toolBar->addAction(ui->actionFind_Replace);
 227
 228     /* Connecting panel show actions */
 229     QObject::connect(ui->actionFile_Panel, SIGNAL(triggered()),
 230                      this, SLOT(showPanel()));
 231     QObject::connect(ui->actionDisplay_Panel, SIGNAL(triggered()),
 232                      this, SLOT(showPanel()));
 233     QObject::connect(ui->actionPreview_Panel, SIGNAL(triggered()),
 234                      this, SLOT(showPanel()));
 235     QObject::connect(ui->actionDevice_Configuration, SIGNAL(triggered()),
 236                      deviceDock, SLOT(show()));
 237     QObject::connect(ui->actionTimer, SIGNAL(triggered()),
 238                      timerDock, SLOT(show()));
 239
 240     /* Connecting the document management actions */
 241     QObject::connect(ui->actionNew_Document, SIGNAL(triggered()),
 242                      this, SLOT(newTab()));
 243     QObject::connect(ui->actionNew_Project, SIGNAL(triggered()),
 244                      this, SLOT(newProject()));
 245
 246     QObject::connect(ui->actionClose_Document, SIGNAL(triggered()),
 247                      this, SLOT(closeCurrent()));
 248     QObject::connect(ui->actionClose_Project, SIGNAL(triggered()),
 249                      this, SLOT(closeProject()));
 250
 251     QObject::connect(ui->actionSave_Document, SIGNAL(triggered()),
 252                      this, SLOT(saveCurrent()));
 253     QObject::connect(ui->actionSave_Document_As, SIGNAL(triggered()),
 254                      this, SLOT(saveCurrentAs()));
 255     QObject::connect(ui->actionExport_Project, SIGNAL(triggered()),
 256                      this, SLOT(exportProject()));
 257
 258     QObject::connect(ui->actionOpen_Document, SIGNAL(triggered()),
 259                      this, SLOT(openFile()));
 260
 261     QObject::connect(ui->actionOpen_Project, SIGNAL(triggered()),
 262                      this, SLOT(openProject()));
 263
 264     /* Connecting the edit menu */
 265     QObject::connect(ui->actionUndo, SIGNAL(triggered()),
 266                      this, SLOT(undo()));
 267     QObject::connect(ui->actionRedo, SIGNAL(triggered()),
 268                      this, SLOT(redo()));
 269     QObject::connect(ui->actionCut, SIGNAL(triggered()),
 270                      this, SLOT(cut()));
 271     QObject::connect(ui->actionCopy, SIGNAL(triggered()),
 272                      this, SLOT(copy()));
 273     QObject::connect(ui->actionPaste, SIGNAL(triggered()),
 274                      this, SLOT(paste()));
 275     QObject::connect(ui->actionFind_Replace, SIGNAL(triggered()),
 276                      this, SLOT(findReplace()));
 277
 278     /* Adding the recent docs/projects menus */
 279     for(int i = 0; i < numRecent; i++)
 280     {
 281         recentDocsMenu.append(new QAction(tr("Recent Doc"),
 282                                           ui->menuRecent_Files));
 283         recentDocsMenu.last()
 284                 ->setShortcut(QKeySequence(tr("CTRL+")
 285                                            + QString::number(i + 1)));
 286         QObject::connect(recentDocsMenu.last(), SIGNAL(triggered()),
 287                          this, SLOT(openRecentFile()));
 288         ui->menuRecent_Files->addAction(recentDocsMenu.last());
 289
 290
 291         recentProjectsMenu.append(new QAction(tr("Recent Project"),
 292                                               ui->menuRecent_Projects));
 293         recentProjectsMenu.last()
 294                 ->setShortcut(QKeySequence(tr("CTRL+SHIFT+") +
 295                                            QString::number(i + 1)));
 296         QObject::connect(recentProjectsMenu.last(), SIGNAL(triggered()),
 297                          this, SLOT(openRecentProject()));
 298         ui->menuRecent_Projects->addAction(recentProjectsMenu.last());
 299     }
 300     refreshRecentMenus();
 301 }
 302
 303 void EditorWindow::addTab(TabContent *doc)
 304 {
 305     ui->editorTabs->addTab(doc, doc->title());
 306
 307     /* Connecting to title change events */
 308     QObject::connect(doc, SIGNAL(titleChanged(QString)),
 309                      this, SLOT(tabTitleChanged(QString)));
 310     QObject::connect(doc, SIGNAL(lineChanged(int)),
 311                      this, SLOT(lineChanged(int)));
 312
 313     /* Connecting to settings change events */
 314     doc->connectPrefs(prefs);
 315 }
 316
 317
 318 void EditorWindow::newTab()
 319 {
 320     SkinDocument* doc = new SkinDocument(parseStatus, project, deviceConfig);
 321     addTab(doc);
 322     ui->editorTabs->setCurrentWidget(doc);
 323 }
 324
 325 void EditorWindow::newProject()
 326 {
 327     NewProjectDialog dialog(this);
 328     if(dialog.exec() == QDialog::Rejected)
 329         return;
 330
 331     /* Assembling the new project if the dialog was accepted */
 332     NewProjectDialog::NewProjectInfo info = dialog.results();
 333
 334     QDir path(info.path);
 335     if(!path.exists())
 336     {
 337         QMessageBox::warning(this, tr("Error Creating Project"), tr("Error:"
 338                              " Project directory does not exist"));
 339         return;
 340     }
 341
 342     if(path.exists(info.name))
 343     {
 344         QMessageBox::warning(this, tr("Error Creating Project"), tr("Error:"
 345                              " Project directory already exists"));
 346         return;
 347     }
 348
 349     if(!path.mkdir(info.name))
 350     {
 351         QMessageBox::warning(this, tr("Error Creating Project"), tr("Error:"
 352                              " Project directory not writeable"));
 353         return;
 354     }
 355
 356     path.cd(info.name);
 357
 358     /* Making standard directories */
 359     path.mkdir("fonts");
 360     path.mkdir("icons");
 361     path.mkdir("backdrops");
 362
 363     /* Adding the desired wps documents */
 364     path.mkdir("wps");
 365     path.cd("wps");
 366
 367     if(info.sbs)
 368         createFile(path.filePath(info.name + ".sbs"), tr("# SBS Document\n"));
 369     if(info.wps)
 370         createFile(path.filePath(info.name + ".wps"), tr("# WPS Document\n"));
 371     if(info.fms)
 372         createFile(path.filePath(info.name + ".fms"), tr("# FMS Document\n"));
 373     if(info.rsbs)
 374         createFile(path.filePath(info.name + ".rsbs"), tr("# RSBS Document\n"));
 375     if(info.rwps)
 376         createFile(path.filePath(info.name + ".rwps"), tr("# RWPS Document\n"));
 377     if(info.rfms)
 378         createFile(path.filePath(info.name + ".rfms"), tr("# RFMS Document\n"));
 379
 380     path.mkdir(info.name);
 381
 382     path.cdUp();
 383
 384     /* Adding the config file */
 385     path.mkdir("themes");
 386     path.cd("themes");
 387
 388     /* Generating the config file */
 389     QString config = tr("# Config file for ") + info.name + "\n";
 390     config.append("#target: " + info.target + "\n\n");
 391     QString wpsBase = "/.rockbox/wps/";
 392     if(info.sbs)
 393         config.append("sbs: " + wpsBase + info.name + ".sbs\n");
 394     if(info.wps)
 395         config.append("wps: " + wpsBase + info.name + ".wps\n");
 396     if(info.fms)
 397         config.append("fms: " + wpsBase + info.name + ".fms\n");
 398     if(info.rsbs)
 399         config.append("rsbs: " + wpsBase + info.name + ".rsbs\n");
 400     if(info.rwps)
 401         config.append("rwps: " + wpsBase + info.name + ".rwps\n");
 402     if(info.rfms)
 403         config.append("rfms: " + wpsBase + info.name + ".rfms\n");
 404
 405
 406     createFile(path.filePath(info.name + ".cfg"),
 407                config);
 408
 409     /* Opening the new project */
 410     loadProjectFile(path.filePath(info.name + ".cfg"));
 411 }
 412
 413 void EditorWindow::shiftTab(int index)
 414 {
 415     TabContent* widget = dynamic_cast<TabContent*>
 416                          (ui->editorTabs->currentWidget());
 417     if(index < 0)
 418     {
 419         ui->parseTree->setModel(0);
 420         ui->actionSave_Document->setEnabled(false);
 421         ui->actionSave_Document_As->setEnabled(false);
 422         ui->actionClose_Document->setEnabled(false);
 423         ui->fromTree->setEnabled(false);
 424         ui->actionUndo->setEnabled(false);
 425         ui->actionRedo->setEnabled(false);
 426         ui->actionCut->setEnabled(false);
 427         ui->actionCopy->setEnabled(false);
 428         ui->actionPaste->setEnabled(false);
 429         ui->actionFind_Replace->setEnabled(false);
 430         viewer->connectSkin(0);
 431     }
 432     else if(widget->type() == TabContent::Config)
 433     {
 434         ui->actionSave_Document->setEnabled(true);
 435         ui->actionSave_Document_As->setEnabled(true);
 436         ui->actionClose_Document->setEnabled(true);
 437         ui->actionUndo->setEnabled(false);
 438         ui->actionRedo->setEnabled(false);
 439         ui->actionCut->setEnabled(false);
 440         ui->actionCopy->setEnabled(false);
 441         ui->actionPaste->setEnabled(false);
 442         ui->actionFind_Replace->setEnabled(false);
 443         viewer->connectSkin(0);
 444     }
 445     else if(widget->type() == TabContent::Skin)
 446     {
 447         /* Syncing the tree view and the status bar */
 448         SkinDocument* doc = dynamic_cast<SkinDocument*>(widget);
 449         ui->parseTree->setModel(doc->getModel());
 450         parseStatus->setText(doc->getStatus());
 451
 452         ui->actionSave_Document->setEnabled(true);
 453         ui->actionSave_Document_As->setEnabled(true);
 454         ui->actionClose_Document->setEnabled(true);
 455         ui->fromTree->setEnabled(true);
 456
 457         ui->actionUndo->setEnabled(true);
 458         ui->actionRedo->setEnabled(true);
 459         ui->actionCut->setEnabled(true);
 460         ui->actionCopy->setEnabled(true);
 461         ui->actionPaste->setEnabled(true);
 462         ui->actionFind_Replace->setEnabled(true);
 463
 464         sizeColumns();
 465
 466         /* Syncing the preview */
 467         viewer->connectSkin(doc);
 468
 469
 470     }
 471
 472     /* Hiding all the find/replace dialogs */
 473     for(int i = 0; i < ui->editorTabs->count(); i++)
 474         if(dynamic_cast<TabContent*>(ui->editorTabs->widget(i))->type() ==
 475            TabContent::Skin)
 476             dynamic_cast<SkinDocument*>(ui->editorTabs->widget(i))->hideFind();
 477
 478 }
 479
 480 bool EditorWindow::closeTab(int index)
 481 {
 482     TabContent* widget = dynamic_cast<TabContent*>
 483                            (ui->editorTabs->widget(index));
 484     if(widget->requestClose())
 485     {
 486         ui->editorTabs->removeTab(index);
 487         widget->deleteLater();
 488         return true;
 489     }
 490
 491     return false;
 492 }
 493
 494 void EditorWindow::closeCurrent()
 495 {
 496     closeTab(ui->editorTabs->currentIndex());
 497 }
 498
 499 void EditorWindow::closeProject()
 500 {
 501     if(project)
 502     {
 503         project->deleteLater();
 504         project = 0;
 505     }
 506
 507     for(int i = 0; i < ui->editorTabs->count(); i++)
 508     {
 509         TabContent* doc = dynamic_cast<TabContent*>
 510                           (ui->editorTabs->widget(i));
 511         if(doc->type() == TabContent::Skin)
 512         {
 513             dynamic_cast<SkinDocument*>(doc)->setProject(project);
 514             if(i == ui->editorTabs->currentIndex())
 515             {
 516                 viewer->connectSkin(dynamic_cast<SkinDocument*>(doc));
 517             }
 518         }
 519     }
 520
 521     ui->actionClose_Project->setEnabled(false);
 522     ui->actionExport_Project->setEnabled(false);
 523 }
 524
 525 void EditorWindow::saveCurrent()
 526 {
 527     if(ui->editorTabs->currentIndex() >= 0)
 528         dynamic_cast<TabContent*>(ui->editorTabs->currentWidget())->save();
 529 }
 530
 531 void EditorWindow::saveCurrentAs()
 532 {
 533     if(ui->editorTabs->currentIndex() >= 0)
 534         dynamic_cast<TabContent*>(ui->editorTabs->currentWidget())->saveAs();
 535 }
 536
 537 void EditorWindow::exportProject()
 538 {
 539     QDir dir = project->getSetting("themebase", "");
 540     dir.cdUp();
 541     QString file = project->getSetting("configfile", "").split("/").
 542                    last().split(".").first() + ".zip";
 543     file = dir.filePath(file);
 544
 545     file = QFileDialog::getSaveFileName(this, tr("Export Project"),
 546                                         file, "Zip Files (*.zip *.ZIP);;"
 547                                               "All Files (*)");
 548
 549     if(file != "")
 550     {
 551         ProjectExporter* exporter = new ProjectExporter(file, project, this);
 552         exporter->show();
 553     }
 554 }
 555
 556 void EditorWindow::openFile()
 557 {
 558     QStringList fileNames;
 559     QSettings settings;
 560
 561     settings.beginGroup("SkinDocument");
 562     QString directory = settings.value("defaultDirectory", "").toString();
 563     fileNames = QFileDialog::getOpenFileNames(this, tr("Open Files"), directory,
 564                                               SkinDocument::fileFilter());
 565
 566     for(int i = 0; i < fileNames.count(); i++)
 567     {
 568         if(!QFile::exists(fileNames[i]))
 569             continue;
 570
 571         QString current = fileNames[i];
 572
 573         loadTabFromSkinFile(current);
 574
 575         /* And setting the new default directory */
 576         current.chop(current.length() - current.lastIndexOf('/') - 1);
 577         settings.setValue("defaultDirectory", current);
 578
 579     }
 580
 581     settings.endGroup();
 582 }
 583
 584 void EditorWindow::openProject()
 585 {
 586     QString fileName;
 587     QSettings settings;
 588
 589     settings.beginGroup("ProjectModel");
 590     QString directory = settings.value("defaultDirectory", "").toString();
 591     fileName = QFileDialog::getOpenFileName(this, tr("Open Project"), directory,
 592                                             ProjectModel::fileFilter());
 593
 594     settings.endGroup();
 595     loadProjectFile(fileName);
 596
 597 }
 598
 599 void EditorWindow::openRecentFile()
 600 {
 601     loadTabFromSkinFile(dynamic_cast<QAction*>(QObject::sender())->text());
 602 }
 603
 604 void EditorWindow::openRecentProject()
 605 {
 606     loadProjectFile(dynamic_cast<QAction*>(QObject::sender())->text());
 607 }
 608
 609 void EditorWindow::configFileChanged(QString configFile)
 610 {
 611
 612     if(QFile::exists(configFile))
 613     {
 614
 615         if(project)
 616             delete project;
 617
 618         project = new ProjectModel(configFile, this);
 619         ui->projectTree->setModel(project);
 620
 621         QObject::connect(ui->projectTree, SIGNAL(activated(QModelIndex)),
 622                          project, SLOT(activated(QModelIndex)));
 623
 624         for(int i = 0; i < ui->editorTabs->count(); i++)
 625         {
 626             TabContent* doc = dynamic_cast<TabContent*>
 627                               (ui->editorTabs->widget(i));
 628             if(doc->type() == TabContent::Skin)
 629             {
 630                 dynamic_cast<SkinDocument*>(doc)->setProject(project);
 631                 if(i == ui->editorTabs->currentIndex())
 632                 {
 633                     viewer->connectSkin(dynamic_cast<SkinDocument*>(doc));
 634                 }
 635             }
 636         }
 637
 638     }
 639
 640
 641 }
 642
 643 void EditorWindow::tabTitleChanged(QString title)
 644 {
 645     TabContent* sender = dynamic_cast<TabContent*>(QObject::sender());
 646     ui->editorTabs->setTabText(ui->editorTabs->indexOf(sender), title);
 647 }
 648
 649 void EditorWindow::showPanel()
 650 {
 651     if(sender() == ui->actionFile_Panel)
 652         ui->projectDock->setVisible(true);
 653     if(sender() == ui->actionPreview_Panel)
 654         ui->skinPreviewDock->setVisible(true);
 655     if(sender() == ui->actionDisplay_Panel)
 656         ui->parseTreeDock->setVisible(true);
 657 }
 658
 659 void EditorWindow::closeEvent(QCloseEvent* event)
 660 {
 661
 662     saveSettings();
 663
 664     /* Closing all the tabs */
 665     for(int i = 0; i < ui->editorTabs->count(); i++)
 666     {
 667         if(!dynamic_cast<TabContent*>
 668            (ui->editorTabs->widget(i))->requestClose())
 669         {
 670             event->ignore();
 671             return;
 672         }
 673     }
 674
 675     event->accept();
 676 }
 677
 678 void EditorWindow::updateCurrent()
 679 {
 680     if(ui->editorTabs->currentIndex() < 0)
 681         return;
 682
 683     dynamic_cast<SkinDocument*>
 684             (ui->editorTabs->currentWidget())->genCode();
 685 }
 686
 687 void EditorWindow::lineChanged(int line)
 688 {
 689     QSettings settings;
 690     settings.beginGroup("EditorWindow");
 691
 692     if(settings.value("autoExpandTree", false).toBool())
 693     {
 694         ui->parseTree->collapseAll();
 695         ParseTreeModel* model = dynamic_cast<ParseTreeModel*>
 696                                 (ui->parseTree->model());
 697         parseTreeSelection = new QItemSelectionModel(model);
 698         expandLine(model, QModelIndex(), line,
 699                    settings.value("autoHighlightTree", false).toBool());
 700         sizeColumns();
 701         ui->parseTree->setSelectionModel(parseTreeSelection);
 702     }
 703
 704     settings.endGroup();
 705 }
 706
 707 void EditorWindow::undo()
 708 {
 709     TabContent* doc = dynamic_cast<TabContent*>
 710                       (ui->editorTabs->currentWidget());
 711     if(doc->type() == TabContent::Skin)
 712         dynamic_cast<SkinDocument*>(doc)->getEditor()->undo();
 713 }
 714
 715 void EditorWindow::redo()
 716 {
 717     TabContent* doc = dynamic_cast<TabContent*>
 718                       (ui->editorTabs->currentWidget());
 719     if(doc->type() == TabContent::Skin)
 720         dynamic_cast<SkinDocument*>(doc)->getEditor()->redo();
 721
 722 }
 723
 724 void EditorWindow::cut()
 725 {
 726     TabContent* doc = dynamic_cast<TabContent*>
 727                       (ui->editorTabs->currentWidget());
 728     if(doc->type() == TabContent::Skin)
 729         dynamic_cast<SkinDocument*>(doc)->getEditor()->cut();
 730 }
 731
 732 void EditorWindow::copy()
 733 {
 734     TabContent* doc = dynamic_cast<TabContent*>
 735                       (ui->editorTabs->currentWidget());
 736     if(doc->type() == TabContent::Skin)
 737         dynamic_cast<SkinDocument*>(doc)->getEditor()->copy();
 738 }
 739
 740 void EditorWindow::paste()
 741 {
 742     TabContent* doc = dynamic_cast<TabContent*>
 743                       (ui->editorTabs->currentWidget());
 744     if(doc->type() == TabContent::Skin)
 745         dynamic_cast<SkinDocument*>(doc)->getEditor()->paste();
 746 }
 747
 748 void EditorWindow::findReplace()
 749 {
 750     TabContent* doc = dynamic_cast<TabContent*>
 751                       (ui->editorTabs->currentWidget());
 752     if(doc->type() == TabContent::Skin)
 753         dynamic_cast<SkinDocument*>(doc)->showFind();
 754 }
 755
 756
 757 void EditorWindow::expandLine(ParseTreeModel* model, QModelIndex parent,
 758                               int line, bool highlight)
 759 {
 760     for(int i = 0; i < model->rowCount(parent); i++)
 761     {
 762         QModelIndex dataType = model->index(i, ParseTreeModel::typeColumn,
 763                                             parent);
 764         QModelIndex dataVal = model->index(i, ParseTreeModel::valueColumn,
 765                                            parent);
 766         QModelIndex data = model->index(i, ParseTreeModel::lineColumn, parent);
 767         QModelIndex recurse = model->index(i, 0, parent);
 768
 769         expandLine(model, recurse, line, highlight);
 770
 771         if(model->data(data, Qt::DisplayRole) == line)
 772         {
 773             ui->parseTree->expand(parent);
 774             ui->parseTree->expand(data);
 775             ui->parseTree->scrollTo(parent, QAbstractItemView::PositionAtTop);
 776
 777             if(highlight)
 778             {
 779                 parseTreeSelection->select(data,
 780                                            QItemSelectionModel::Select);
 781                 parseTreeSelection->select(dataType,
 782                                            QItemSelectionModel::Select);
 783                 parseTreeSelection->select(dataVal,
 784                                            QItemSelectionModel::Select);
 785             }
 786         }
 787     }
 788
 789 }
 790
 791 void EditorWindow::sizeColumns()
 792 {
 793     /* Setting the column widths */
 794     ui->parseTree->resizeColumnToContents(ParseTreeModel::lineColumn);
 795     ui->parseTree->resizeColumnToContents(ParseTreeModel::typeColumn);
 796     ui->parseTree->resizeColumnToContents(ParseTreeModel::valueColumn);
 797 }
 798
 799 void EditorWindow::loadProjectFile(QString fileName)
 800 {
 801     QSettings settings;
 802     settings.beginGroup("ProjectModel");
 803
 804     if(QFile::exists(fileName))
 805     {
 806         projectToTop(fileName);
 807
 808         if(project)
 809             project->deleteLater();
 810
 811         ui->actionClose_Project->setEnabled(true);
 812         ui->actionExport_Project->setEnabled(true);
 813
 814         project = new ProjectModel(fileName, this);
 815         ui->projectTree->setModel(project);
 816
 817         /* Setting target info if necessary */
 818         TargetData targets;
 819         QString target = project->getSetting("#target", "");
 820         if(target != "" && targets.index(target) >= 0)
 821         {
 822             int index = targets.index(target);
 823
 824             QRect screen = targets.screenSize(index);
 825             deviceConfig->setData("screenwidth", screen.width());
 826             deviceConfig->setData("screenheight", screen.height());
 827
 828             if(targets.remoteDepth(index) != TargetData::None)
 829             {
 830                 QRect remote = targets.remoteSize(index);
 831                 deviceConfig->setData("remotewidth", remote.width());
 832                 deviceConfig->setData("remoteheight", remote.height());
 833             }
 834
 835             deviceConfig->setData("tp", targets.fm(index));
 836             deviceConfig->setData("Rp", targets.canRecord(index));
 837         }
 838
 839         if(project->getSetting("#screenwidth") != "")
 840             deviceConfig->setData("screenwidth",
 841                                   project->getSetting("#screenwidth"));
 842         if(project->getSetting("#screenheight") != "")
 843             deviceConfig->setData("screenheight",
 844                                   project->getSetting("#screenheight"));
 845
 846         QObject::connect(ui->projectTree, SIGNAL(activated(QModelIndex)),
 847                          project, SLOT(activated(QModelIndex)));
 848
 849         fileName.chop(fileName.length() - fileName.lastIndexOf('/') - 1);
 850         settings.setValue("defaultDirectory", fileName);
 851
 852         for(int i = 0; i < ui->editorTabs->count(); i++)
 853         {
 854             TabContent* doc = dynamic_cast<TabContent*>
 855                               (ui->editorTabs->widget(i));
 856             if(doc->type() == TabContent::Skin)
 857             {
 858                 dynamic_cast<SkinDocument*>(doc)->setProject(project);
 859                 if(i == ui->editorTabs->currentIndex())
 860                 {
 861                     viewer->connectSkin(dynamic_cast<SkinDocument*>(doc));
 862                 }
 863             }
 864         }
 865
 866     }
 867
 868     settings.endGroup();
 869
 870 }
 871
 872 void EditorWindow::createFile(QString filename, QString contents)
 873 {
 874     QFile fout(filename);
 875     fout.open(QFile::WriteOnly);
 876
 877     fout.write(contents.toAscii());
 878
 879     fout.close();
 880 }
 881
 882 void EditorWindow::docToTop(QString file)
 883 {
 884     if(!QFile::exists(file))
 885         return;
 886
 887     int index = recentDocs.indexOf(file);
 888     if(index == -1)
 889     {
 890         /* Bumping off the last file */
 891         if(recentDocs.count() >= numRecent)
 892             recentDocs.removeLast();
 893         recentDocs.prepend(file);
 894     }
 895     else
 896     {
 897         /* Shuffling file to the top of the list */
 898         recentDocs.removeAt(index);
 899         recentDocs.prepend(file);
 900     }
 901
 902     refreshRecentMenus();
 903 }
 904
 905 void EditorWindow::projectToTop(QString file)
 906 {
 907     if(!QFile::exists(file))
 908         return;
 909
 910     int index = recentProjects.indexOf(file);
 911     if(index == -1)
 912     {
 913         /* Bumping off the last project */
 914         if(recentProjects.count() >= numRecent)
 915             recentProjects.removeLast();
 916         recentProjects.prepend(file);
 917     }
 918     else
 919     {
 920         /* Shuffling file to the top of the list */
 921         recentProjects.removeAt(index);
 922         recentProjects.prepend(file);
 923     }
 924
 925     refreshRecentMenus();
 926 }
 927
 928 void EditorWindow::refreshRecentMenus()
 929 {
 930     /* Clearing any deleted documents */
 931     for(int i = 0; i < recentDocs.count(); i++)
 932         if(!QFile::exists(recentDocs[i]))
 933             recentDocs.removeAt(i--);
 934
 935     /* Clearing any deleted projects */
 936     for(int i = 0; i < recentProjects.count(); i++)
 937         if(!QFile::exists(recentProjects[i]))
 938             recentProjects.removeAt(i--);
 939
 940     /* First hiding all the menu items */
 941     for(int i = 0; i < recentDocsMenu.count(); i++)
 942         recentDocsMenu[i]->setVisible(false);
 943     for(int i = 0; i < recentProjectsMenu.count(); i++)
 944         recentProjectsMenu[i]->setVisible(false);
 945
 946     /* Then setting the text of and showing any available */
 947     for(int i = 0; i < recentDocs.count(); i++)
 948     {
 949         recentDocsMenu[i]->setText(recentDocs[i]);
 950         recentDocsMenu[i]->setVisible(true);
 951     }
 952
 953     for(int i = 0; i < recentProjects.count(); i++)
 954     {
 955         recentProjectsMenu[i]->setText(recentProjects[i]);
 956         recentProjectsMenu[i]->setVisible(true);
 957     }
 958 }