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     /* Connecting panel show actions */
 211     QObject::connect(ui->actionFile_Panel, SIGNAL(triggered()),
 212                      this, SLOT(showPanel()));
 213     QObject::connect(ui->actionDisplay_Panel, SIGNAL(triggered()),
 214                      this, SLOT(showPanel()));
 215     QObject::connect(ui->actionPreview_Panel, SIGNAL(triggered()),
 216                      this, SLOT(showPanel()));
 217     QObject::connect(ui->actionDevice_Configuration, SIGNAL(triggered()),
 218                      deviceDock, SLOT(show()));
 219     QObject::connect(ui->actionTimer, SIGNAL(triggered()),
 220                      timerDock, SLOT(show()));
 221
 222     /* Connecting the document management actions */
 223     QObject::connect(ui->actionNew_Document, SIGNAL(triggered()),
 224                      this, SLOT(newTab()));
 225     QObject::connect(ui->actionNew_Project, SIGNAL(triggered()),
 226                      this, SLOT(newProject()));
 227     QObject::connect(ui->actionToolbarNew, SIGNAL(triggered()),
 228                      this, SLOT(newTab()));
 229
 230     QObject::connect(ui->actionClose_Document, SIGNAL(triggered()),
 231                      this, SLOT(closeCurrent()));
 232     QObject::connect(ui->actionClose_Project, SIGNAL(triggered()),
 233                      this, SLOT(closeProject()));
 234
 235     QObject::connect(ui->actionSave_Document, SIGNAL(triggered()),
 236                      this, SLOT(saveCurrent()));
 237     QObject::connect(ui->actionSave_Document_As, SIGNAL(triggered()),
 238                      this, SLOT(saveCurrentAs()));
 239     QObject::connect(ui->actionToolbarSave, SIGNAL(triggered()),
 240                      this, SLOT(saveCurrent()));
 241     QObject::connect(ui->actionExport_Project, SIGNAL(triggered()),
 242                      this, SLOT(exportProject()));
 243
 244     QObject::connect(ui->actionOpen_Document, SIGNAL(triggered()),
 245                      this, SLOT(openFile()));
 246     QObject::connect(ui->actionToolbarOpen, SIGNAL(triggered()),
 247                      this, SLOT(openFile()));
 248
 249     QObject::connect(ui->actionOpen_Project, SIGNAL(triggered()),
 250                      this, SLOT(openProject()));
 251
 252     /* Connecting the edit menu */
 253     QObject::connect(ui->actionUndo, SIGNAL(triggered()),
 254                      this, SLOT(undo()));
 255     QObject::connect(ui->actionRedo, SIGNAL(triggered()),
 256                      this, SLOT(redo()));
 257     QObject::connect(ui->actionCut, SIGNAL(triggered()),
 258                      this, SLOT(cut()));
 259     QObject::connect(ui->actionCopy, SIGNAL(triggered()),
 260                      this, SLOT(copy()));
 261     QObject::connect(ui->actionPaste, SIGNAL(triggered()),
 262                      this, SLOT(paste()));
 263     QObject::connect(ui->actionFind_Replace, SIGNAL(triggered()),
 264                      this, SLOT(findReplace()));
 265
 266     /* Adding the recent docs/projects menus */
 267     for(int i = 0; i < numRecent; i++)
 268     {
 269         recentDocsMenu.append(new QAction(tr("Recent Doc"),
 270                                           ui->menuRecent_Files));
 271         recentDocsMenu.last()
 272                 ->setShortcut(QKeySequence(tr("CTRL+")
 273                                            + QString::number(i + 1)));
 274         QObject::connect(recentDocsMenu.last(), SIGNAL(triggered()),
 275                          this, SLOT(openRecentFile()));
 276         ui->menuRecent_Files->addAction(recentDocsMenu.last());
 277
 278
 279         recentProjectsMenu.append(new QAction(tr("Recent Project"),
 280                                               ui->menuRecent_Projects));
 281         recentProjectsMenu.last()
 282                 ->setShortcut(QKeySequence(tr("CTRL+SHIFT+") +
 283                                            QString::number(i + 1)));
 284         QObject::connect(recentProjectsMenu.last(), SIGNAL(triggered()),
 285                          this, SLOT(openRecentProject()));
 286         ui->menuRecent_Projects->addAction(recentProjectsMenu.last());
 287     }
 288     refreshRecentMenus();
 289 }
 290
 291 void EditorWindow::addTab(TabContent *doc)
 292 {
 293     ui->editorTabs->addTab(doc, doc->title());
 294
 295     /* Connecting to title change events */
 296     QObject::connect(doc, SIGNAL(titleChanged(QString)),
 297                      this, SLOT(tabTitleChanged(QString)));
 298     QObject::connect(doc, SIGNAL(lineChanged(int)),
 299                      this, SLOT(lineChanged(int)));
 300
 301     /* Connecting to settings change events */
 302     if(doc->type() == TabContent::Skin)
 303         dynamic_cast<SkinDocument*>(doc)->connectPrefs(prefs);
 304 }
 305
 306
 307 void EditorWindow::newTab()
 308 {
 309     SkinDocument* doc = new SkinDocument(parseStatus, project, deviceConfig);
 310     addTab(doc);
 311     ui->editorTabs->setCurrentWidget(doc);
 312 }
 313
 314 void EditorWindow::newProject()
 315 {
 316     NewProjectDialog dialog(this);
 317     if(dialog.exec() == QDialog::Rejected)
 318         return;
 319
 320     /* Assembling the new project if the dialog was accepted */
 321     NewProjectDialog::NewProjectInfo info = dialog.results();
 322
 323     QDir path(info.path);
 324     if(!path.exists())
 325     {
 326         QMessageBox::warning(this, tr("Error Creating Project"), tr("Error:"
 327                              " Project directory does not exist"));
 328         return;
 329     }
 330
 331     if(path.exists(info.name))
 332     {
 333         QMessageBox::warning(this, tr("Error Creating Project"), tr("Error:"
 334                              " Project directory already exists"));
 335         return;
 336     }
 337
 338     if(!path.mkdir(info.name))
 339     {
 340         QMessageBox::warning(this, tr("Error Creating Project"), tr("Error:"
 341                              " Project directory not writeable"));
 342         return;
 343     }
 344
 345     path.cd(info.name);
 346
 347     /* Making standard directories */
 348     path.mkdir("fonts");
 349     path.mkdir("icons");
 350     path.mkdir("backdrops");
 351
 352     /* Adding the desired wps documents */
 353     path.mkdir("wps");
 354     path.cd("wps");
 355
 356     if(info.sbs)
 357         createFile(path.filePath(info.name + ".sbs"), tr("# SBS Document\n"));
 358     if(info.wps)
 359         createFile(path.filePath(info.name + ".wps"), tr("# WPS Document\n"));
 360     if(info.fms)
 361         createFile(path.filePath(info.name + ".fms"), tr("# FMS Document\n"));
 362     if(info.rsbs)
 363         createFile(path.filePath(info.name + ".rsbs"), tr("# RSBS Document\n"));
 364     if(info.rwps)
 365         createFile(path.filePath(info.name + ".rwps"), tr("# RWPS Document\n"));
 366     if(info.rfms)
 367         createFile(path.filePath(info.name + ".rfms"), tr("# RFMS Document\n"));
 368
 369     path.mkdir(info.name);
 370
 371     path.cdUp();
 372
 373     /* Adding the config file */
 374     path.mkdir("themes");
 375     path.cd("themes");
 376
 377     /* Generating the config file */
 378     QString config = tr("# Config file for ") + info.name + "\n";
 379     config.append("#target: " + info.target + "\n\n");
 380     QString wpsBase = "/.rockbox/wps/";
 381     if(info.sbs)
 382         config.append("sbs: " + wpsBase + info.name + ".sbs\n");
 383     if(info.wps)
 384         config.append("wps: " + wpsBase + info.name + ".wps\n");
 385     if(info.fms)
 386         config.append("fms: " + wpsBase + info.name + ".fms\n");
 387     if(info.rsbs)
 388         config.append("rsbs: " + wpsBase + info.name + ".rsbs\n");
 389     if(info.rwps)
 390         config.append("rwps: " + wpsBase + info.name + ".rwps\n");
 391     if(info.rfms)
 392         config.append("rfms: " + wpsBase + info.name + ".rfms\n");
 393
 394
 395     createFile(path.filePath(info.name + ".cfg"),
 396                config);
 397
 398     /* Opening the new project */
 399     loadProjectFile(path.filePath(info.name + ".cfg"));
 400 }
 401
 402 void EditorWindow::shiftTab(int index)
 403 {
 404     TabContent* widget = dynamic_cast<TabContent*>
 405                          (ui->editorTabs->currentWidget());
 406     if(index < 0)
 407     {
 408         ui->parseTree->setModel(0);
 409         ui->actionSave_Document->setEnabled(false);
 410         ui->actionSave_Document_As->setEnabled(false);
 411         ui->actionClose_Document->setEnabled(false);
 412         ui->actionToolbarSave->setEnabled(false);
 413         ui->fromTree->setEnabled(false);
 414         ui->actionUndo->setEnabled(false);
 415         ui->actionRedo->setEnabled(false);
 416         ui->actionCut->setEnabled(false);
 417         ui->actionCopy->setEnabled(false);
 418         ui->actionPaste->setEnabled(false);
 419         ui->actionFind_Replace->setEnabled(false);
 420         viewer->setScene(0);
 421     }
 422     else if(widget->type() == TabContent::Config)
 423     {
 424         ui->actionSave_Document->setEnabled(true);
 425         ui->actionSave_Document_As->setEnabled(true);
 426         ui->actionClose_Document->setEnabled(true);
 427         ui->actionToolbarSave->setEnabled(true);
 428         ui->actionUndo->setEnabled(false);
 429         ui->actionRedo->setEnabled(false);
 430         ui->actionCut->setEnabled(false);
 431         ui->actionCopy->setEnabled(false);
 432         ui->actionPaste->setEnabled(false);
 433         ui->actionFind_Replace->setEnabled(false);
 434         viewer->setScene(0);
 435     }
 436     else if(widget->type() == TabContent::Skin)
 437     {
 438         /* Syncing the tree view and the status bar */
 439         SkinDocument* doc = dynamic_cast<SkinDocument*>(widget);
 440         ui->parseTree->setModel(doc->getModel());
 441         parseStatus->setText(doc->getStatus());
 442
 443         ui->actionSave_Document->setEnabled(true);
 444         ui->actionSave_Document_As->setEnabled(true);
 445         ui->actionClose_Document->setEnabled(true);
 446         ui->actionToolbarSave->setEnabled(true);
 447         ui->fromTree->setEnabled(true);
 448
 449         ui->actionUndo->setEnabled(true);
 450         ui->actionRedo->setEnabled(true);
 451         ui->actionCut->setEnabled(true);
 452         ui->actionCopy->setEnabled(true);
 453         ui->actionPaste->setEnabled(true);
 454         ui->actionFind_Replace->setEnabled(true);
 455
 456         sizeColumns();
 457
 458         /* Syncing the preview */
 459         viewer->setScene(doc->scene());
 460
 461     }
 462
 463     /* Hiding all the find/replace dialogs */
 464     for(int i = 0; i < ui->editorTabs->count(); i++)
 465         if(dynamic_cast<TabContent*>(ui->editorTabs->widget(i))->type() ==
 466            TabContent::Skin)
 467             dynamic_cast<SkinDocument*>(ui->editorTabs->widget(i))->hideFind();
 468
 469 }
 470
 471 bool EditorWindow::closeTab(int index)
 472 {
 473     TabContent* widget = dynamic_cast<TabContent*>
 474                            (ui->editorTabs->widget(index));
 475     if(widget->requestClose())
 476     {
 477         ui->editorTabs->removeTab(index);
 478         widget->deleteLater();
 479         return true;
 480     }
 481
 482     return false;
 483 }
 484
 485 void EditorWindow::closeCurrent()
 486 {
 487     closeTab(ui->editorTabs->currentIndex());
 488 }
 489
 490 void EditorWindow::closeProject()
 491 {
 492     if(project)
 493     {
 494         project->deleteLater();
 495         project = 0;
 496     }
 497
 498     for(int i = 0; i < ui->editorTabs->count(); i++)
 499     {
 500         TabContent* doc = dynamic_cast<TabContent*>
 501                           (ui->editorTabs->widget(i));
 502         if(doc->type() == TabContent::Skin)
 503         {
 504             dynamic_cast<SkinDocument*>(doc)->setProject(project);
 505             if(i == ui->editorTabs->currentIndex())
 506             {
 507                 viewer->setScene(dynamic_cast<SkinDocument*>(doc)->scene());
 508             }
 509         }
 510     }
 511
 512     ui->actionClose_Project->setEnabled(false);
 513     ui->actionExport_Project->setEnabled(false);
 514 }
 515
 516 void EditorWindow::saveCurrent()
 517 {
 518     if(ui->editorTabs->currentIndex() >= 0)
 519         dynamic_cast<TabContent*>(ui->editorTabs->currentWidget())->save();
 520 }
 521
 522 void EditorWindow::saveCurrentAs()
 523 {
 524     if(ui->editorTabs->currentIndex() >= 0)
 525         dynamic_cast<TabContent*>(ui->editorTabs->currentWidget())->saveAs();
 526 }
 527
 528 void EditorWindow::exportProject()
 529 {
 530     QDir dir = project->getSetting("themebase", "");
 531     dir.cdUp();
 532     QString file = project->getSetting("configfile", "").split("/").
 533                    last().split(".").first() + ".zip";
 534     file = dir.filePath(file);
 535
 536     file = QFileDialog::getSaveFileName(this, tr("Export Project"),
 537                                         file, "Zip Files (*.zip *.ZIP);;"
 538                                               "All Files (*)");
 539
 540     if(file != "")
 541     {
 542         ProjectExporter* exporter = new ProjectExporter(file, project, this);
 543         exporter->show();
 544     }
 545 }
 546
 547 void EditorWindow::openFile()
 548 {
 549     QStringList fileNames;
 550     QSettings settings;
 551
 552     settings.beginGroup("SkinDocument");
 553     QString directory = settings.value("defaultDirectory", "").toString();
 554     fileNames = QFileDialog::getOpenFileNames(this, tr("Open Files"), directory,
 555                                               SkinDocument::fileFilter());
 556
 557     for(int i = 0; i < fileNames.count(); i++)
 558     {
 559         if(!QFile::exists(fileNames[i]))
 560             continue;
 561
 562         QString current = fileNames[i];
 563
 564         loadTabFromSkinFile(current);
 565
 566         /* And setting the new default directory */
 567         current.chop(current.length() - current.lastIndexOf('/') - 1);
 568         settings.setValue("defaultDirectory", current);
 569
 570     }
 571
 572     settings.endGroup();
 573 }
 574
 575 void EditorWindow::openProject()
 576 {
 577     QString fileName;
 578     QSettings settings;
 579
 580     settings.beginGroup("ProjectModel");
 581     QString directory = settings.value("defaultDirectory", "").toString();
 582     fileName = QFileDialog::getOpenFileName(this, tr("Open Project"), directory,
 583                                             ProjectModel::fileFilter());
 584
 585     settings.endGroup();
 586     loadProjectFile(fileName);
 587
 588 }
 589
 590 void EditorWindow::openRecentFile()
 591 {
 592     loadTabFromSkinFile(dynamic_cast<QAction*>(QObject::sender())->text());
 593 }
 594
 595 void EditorWindow::openRecentProject()
 596 {
 597     loadProjectFile(dynamic_cast<QAction*>(QObject::sender())->text());
 598 }
 599
 600 void EditorWindow::configFileChanged(QString configFile)
 601 {
 602
 603     if(QFile::exists(configFile))
 604     {
 605
 606         if(project)
 607             delete project;
 608
 609         project = new ProjectModel(configFile, this);
 610         ui->projectTree->setModel(project);
 611
 612         QObject::connect(ui->projectTree, SIGNAL(activated(QModelIndex)),
 613                          project, SLOT(activated(QModelIndex)));
 614
 615         for(int i = 0; i < ui->editorTabs->count(); i++)
 616         {
 617             TabContent* doc = dynamic_cast<TabContent*>
 618                               (ui->editorTabs->widget(i));
 619             if(doc->type() == TabContent::Skin)
 620             {
 621                 dynamic_cast<SkinDocument*>(doc)->setProject(project);
 622                 if(i == ui->editorTabs->currentIndex())
 623                 {
 624                     viewer->setScene(dynamic_cast<SkinDocument*>(doc)->scene());
 625                 }
 626             }
 627         }
 628
 629     }
 630
 631
 632 }
 633
 634 void EditorWindow::tabTitleChanged(QString title)
 635 {
 636     TabContent* sender = dynamic_cast<TabContent*>(QObject::sender());
 637     ui->editorTabs->setTabText(ui->editorTabs->indexOf(sender), title);
 638 }
 639
 640 void EditorWindow::showPanel()
 641 {
 642     if(sender() == ui->actionFile_Panel)
 643         ui->projectDock->setVisible(true);
 644     if(sender() == ui->actionPreview_Panel)
 645         ui->skinPreviewDock->setVisible(true);
 646     if(sender() == ui->actionDisplay_Panel)
 647         ui->parseTreeDock->setVisible(true);
 648 }
 649
 650 void EditorWindow::closeEvent(QCloseEvent* event)
 651 {
 652
 653     saveSettings();
 654
 655     /* Closing all the tabs */
 656     for(int i = 0; i < ui->editorTabs->count(); i++)
 657     {
 658         if(!dynamic_cast<TabContent*>
 659            (ui->editorTabs->widget(i))->requestClose())
 660         {
 661             event->ignore();
 662             return;
 663         }
 664     }
 665
 666     event->accept();
 667 }
 668
 669 void EditorWindow::updateCurrent()
 670 {
 671     if(ui->editorTabs->currentIndex() < 0)
 672         return;
 673
 674     dynamic_cast<SkinDocument*>
 675             (ui->editorTabs->currentWidget())->genCode();
 676 }
 677
 678 void EditorWindow::lineChanged(int line)
 679 {
 680     QSettings settings;
 681     settings.beginGroup("EditorWindow");
 682
 683     if(settings.value("autoExpandTree", false).toBool())
 684     {
 685         ui->parseTree->collapseAll();
 686         ParseTreeModel* model = dynamic_cast<ParseTreeModel*>
 687                                 (ui->parseTree->model());
 688         parseTreeSelection = new QItemSelectionModel(model);
 689         expandLine(model, QModelIndex(), line,
 690                    settings.value("autoHighlightTree", false).toBool());
 691         sizeColumns();
 692         ui->parseTree->setSelectionModel(parseTreeSelection);
 693     }
 694
 695     settings.endGroup();
 696 }
 697
 698 void EditorWindow::undo()
 699 {
 700     TabContent* doc = dynamic_cast<TabContent*>
 701                       (ui->editorTabs->currentWidget());
 702     if(doc->type() == TabContent::Skin)
 703         dynamic_cast<SkinDocument*>(doc)->getEditor()->undo();
 704 }
 705
 706 void EditorWindow::redo()
 707 {
 708     TabContent* doc = dynamic_cast<TabContent*>
 709                       (ui->editorTabs->currentWidget());
 710     if(doc->type() == TabContent::Skin)
 711         dynamic_cast<SkinDocument*>(doc)->getEditor()->redo();
 712
 713 }
 714
 715 void EditorWindow::cut()
 716 {
 717     TabContent* doc = dynamic_cast<TabContent*>
 718                       (ui->editorTabs->currentWidget());
 719     if(doc->type() == TabContent::Skin)
 720         dynamic_cast<SkinDocument*>(doc)->getEditor()->cut();
 721 }
 722
 723 void EditorWindow::copy()
 724 {
 725     TabContent* doc = dynamic_cast<TabContent*>
 726                       (ui->editorTabs->currentWidget());
 727     if(doc->type() == TabContent::Skin)
 728         dynamic_cast<SkinDocument*>(doc)->getEditor()->copy();
 729 }
 730
 731 void EditorWindow::paste()
 732 {
 733     TabContent* doc = dynamic_cast<TabContent*>
 734                       (ui->editorTabs->currentWidget());
 735     if(doc->type() == TabContent::Skin)
 736         dynamic_cast<SkinDocument*>(doc)->getEditor()->paste();
 737 }
 738
 739 void EditorWindow::findReplace()
 740 {
 741     TabContent* doc = dynamic_cast<TabContent*>
 742                       (ui->editorTabs->currentWidget());
 743     if(doc->type() == TabContent::Skin)
 744         dynamic_cast<SkinDocument*>(doc)->showFind();
 745 }
 746
 747
 748 void EditorWindow::expandLine(ParseTreeModel* model, QModelIndex parent,
 749                               int line, bool highlight)
 750 {
 751     for(int i = 0; i < model->rowCount(parent); i++)
 752     {
 753         QModelIndex dataType = model->index(i, ParseTreeModel::typeColumn,
 754                                             parent);
 755         QModelIndex dataVal = model->index(i, ParseTreeModel::valueColumn,
 756                                            parent);
 757         QModelIndex data = model->index(i, ParseTreeModel::lineColumn, parent);
 758         QModelIndex recurse = model->index(i, 0, parent);
 759
 760         expandLine(model, recurse, line, highlight);
 761
 762         if(model->data(data, Qt::DisplayRole) == line)
 763         {
 764             ui->parseTree->expand(parent);
 765             ui->parseTree->expand(data);
 766             ui->parseTree->scrollTo(parent, QAbstractItemView::PositionAtTop);
 767
 768             if(highlight)
 769             {
 770                 parseTreeSelection->select(data,
 771                                            QItemSelectionModel::Select);
 772                 parseTreeSelection->select(dataType,
 773                                            QItemSelectionModel::Select);
 774                 parseTreeSelection->select(dataVal,
 775                                            QItemSelectionModel::Select);
 776             }
 777         }
 778     }
 779
 780 }
 781
 782 void EditorWindow::sizeColumns()
 783 {
 784     /* Setting the column widths */
 785     ui->parseTree->resizeColumnToContents(ParseTreeModel::lineColumn);
 786     ui->parseTree->resizeColumnToContents(ParseTreeModel::typeColumn);
 787     ui->parseTree->resizeColumnToContents(ParseTreeModel::valueColumn);
 788 }
 789
 790 void EditorWindow::loadProjectFile(QString fileName)
 791 {
 792     QSettings settings;
 793     settings.beginGroup("ProjectModel");
 794
 795     if(QFile::exists(fileName))
 796     {
 797         projectToTop(fileName);
 798
 799         if(project)
 800             project->deleteLater();
 801
 802         ui->actionClose_Project->setEnabled(true);
 803         ui->actionExport_Project->setEnabled(true);
 804
 805         project = new ProjectModel(fileName, this);
 806         ui->projectTree->setModel(project);
 807
 808         /* Setting target info if necessary */
 809         TargetData targets;
 810         QString target = project->getSetting("#target", "");
 811         if(target != "" && targets.index(target) >= 0)
 812         {
 813             int index = targets.index(target);
 814
 815             QRect screen = targets.screenSize(index);
 816             deviceConfig->setData("screenwidth", screen.width());
 817             deviceConfig->setData("screenheight", screen.height());
 818
 819             if(targets.remoteDepth(index) != TargetData::None)
 820             {
 821                 QRect remote = targets.remoteSize(index);
 822                 deviceConfig->setData("remotewidth", remote.width());
 823                 deviceConfig->setData("remoteheight", remote.height());
 824             }
 825
 826             deviceConfig->setData("tp", targets.fm(index));
 827             deviceConfig->setData("Rp", targets.canRecord(index));
 828         }
 829
 830         if(project->getSetting("#screenwidth") != "")
 831             deviceConfig->setData("screenwidth",
 832                                   project->getSetting("#screenwidth"));
 833         if(project->getSetting("#screenheight") != "")
 834             deviceConfig->setData("screenheight",
 835                                   project->getSetting("#screenheight"));
 836
 837         QObject::connect(ui->projectTree, SIGNAL(activated(QModelIndex)),
 838                          project, SLOT(activated(QModelIndex)));
 839
 840         fileName.chop(fileName.length() - fileName.lastIndexOf('/') - 1);
 841         settings.setValue("defaultDirectory", fileName);
 842
 843         for(int i = 0; i < ui->editorTabs->count(); i++)
 844         {
 845             TabContent* doc = dynamic_cast<TabContent*>
 846                               (ui->editorTabs->widget(i));
 847             if(doc->type() == TabContent::Skin)
 848             {
 849                 dynamic_cast<SkinDocument*>(doc)->setProject(project);
 850                 if(i == ui->editorTabs->currentIndex())
 851                 {
 852                     viewer->setScene(dynamic_cast<SkinDocument*>(doc)->scene());
 853                 }
 854             }
 855         }
 856
 857     }
 858
 859     settings.endGroup();
 860
 861 }
 862
 863 void EditorWindow::createFile(QString filename, QString contents)
 864 {
 865     QFile fout(filename);
 866     fout.open(QFile::WriteOnly);
 867
 868     fout.write(contents.toAscii());
 869
 870     fout.close();
 871 }
 872
 873 void EditorWindow::docToTop(QString file)
 874 {
 875     if(!QFile::exists(file))
 876         return;
 877
 878     int index = recentDocs.indexOf(file);
 879     if(index == -1)
 880     {
 881         /* Bumping off the last file */
 882         if(recentDocs.count() >= numRecent)
 883             recentDocs.removeLast();
 884         recentDocs.prepend(file);
 885     }
 886     else
 887     {
 888         /* Shuffling file to the top of the list */
 889         recentDocs.removeAt(index);
 890         recentDocs.prepend(file);
 891     }
 892
 893     refreshRecentMenus();
 894 }
 895
 896 void EditorWindow::projectToTop(QString file)
 897 {
 898     if(!QFile::exists(file))
 899         return;
 900
 901     int index = recentProjects.indexOf(file);
 902     if(index == -1)
 903     {
 904         /* Bumping off the last project */
 905         if(recentProjects.count() >= numRecent)
 906             recentProjects.removeLast();
 907         recentProjects.prepend(file);
 908     }
 909     else
 910     {
 911         /* Shuffling file to the top of the list */
 912         recentProjects.removeAt(index);
 913         recentProjects.prepend(file);
 914     }
 915
 916     refreshRecentMenus();
 917 }
 918
 919 void EditorWindow::refreshRecentMenus()
 920 {
 921     /* Clearing any deleted documents */
 922     for(int i = 0; i < recentDocs.count(); i++)
 923         if(!QFile::exists(recentDocs[i]))
 924             recentDocs.removeAt(i--);
 925
 926     /* Clearing any deleted projects */
 927     for(int i = 0; i < recentProjects.count(); i++)
 928         if(!QFile::exists(recentProjects[i]))
 929             recentProjects.removeAt(i--);
 930
 931     /* First hiding all the menu items */
 932     for(int i = 0; i < recentDocsMenu.count(); i++)
 933         recentDocsMenu[i]->setVisible(false);
 934     for(int i = 0; i < recentProjectsMenu.count(); i++)
 935         recentProjectsMenu[i]->setVisible(false);
 936
 937     /* Then setting the text of and showing any available */
 938     for(int i = 0; i < recentDocs.count(); i++)
 939     {
 940         recentDocsMenu[i]->setText(recentDocs[i]);
 941         recentDocsMenu[i]->setVisible(true);
 942     }
 943
 944     for(int i = 0; i < recentProjects.count(); i++)
 945     {
 946         recentProjectsMenu[i]->setText(recentProjects[i]);
 947         recentProjectsMenu[i]->setVisible(true);
 948     }
 949 }