src/shell/projectmanager.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by David Cuadrado                                  *
   3  *   krawek@gmail.com                                                      *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21
  22 #include "projectmanager.h"
  23
  24 // DLIB
  25 #include <dcore/algorithm.h>
  26 #include <dcore/zipper.h>
  27
  28 // YAMF
  29 #include <yamf/model/project.h>
  30 #include <yamf/model/scene.h>
  31 #include <yamf/model/layer.h>
  32 #include <yamf/model/audiolayer.h>
  33 #include <yamf/model/frame.h>
  34 #include <yamf/model/object.h>
  35 #include <yamf/model/library.h>
  36
  37 #include <yamf/model/command/manager.h>
  38 #include <yamf/model/command/base.h>
  39
  40 // DASH
  41 #include "dash/module.h"
  42 #include "dash/commandparser.h"
  43
  44
  45 // Qt
  46 #include <QWidget>
  47 #include <QDir>
  48 #include <QFileInfo>
  49
  50 struct ProjectManager::Private
  51 {
  52         Private() : isLocal(true), project(0), commandCounter(0) {}
  53
  54         bool isLocal;
  55         YAMF::Model::Project *project;
  56
  57         QList<Dash::Module *> modules;
  58
  59         bool deleteProjectDir(const QString &projectDir);
  60         int commandCounter;
  61 };
  62
  63 bool ProjectManager::Private::deleteProjectDir(const QString &projectDir)
  64 {
  65         if(!projectDir.startsWith(".") && QFile::exists( projectDir ) )
  66         {
  67                 QDir dir(projectDir);
  68
  69                 if( (dir.exists("audio") && dir.exists("video") && dir.exists("images")) || dir.exists("project") )
  70                 {
  71                         dDebug() << "Removing " << dir.absolutePath() << "...";
  72
  73                         dir.remove("project");
  74                         dir.remove("library");
  75
  76                         foreach(QString scene, dir.entryList(QStringList() << "scene*", QDir::Files ))
  77                         {
  78                                 dir.remove(scene);
  79                         }
  80
  81                         foreach( QString subdir, QStringList() << "audio" << "video" << "images" << "svg" )
  82                         {
  83                                 if( dir.exists(subdir) )
  84                                 {
  85                                         dir.cd(subdir);
  86                                         foreach(QString file, dir.entryList() )
  87                                         {
  88                                                 QString absolute = dir.absolutePath() + "/" + file;
  89
  90                                                 if( !file.startsWith(".") )
  91                                                 {
  92                                                         QFileInfo finfo(absolute);
  93
  94                                                         if( finfo.isFile() )
  95                                                         {
  96                                                                 QFile::remove(absolute);
  97                                                         }
  98                                                 }
  99                                         }
 100                                         dir.cdUp();
 101                                         dir.rmdir(subdir);
 102                                 }
 103                         }
 104
 105                         if( ! dir.rmdir(dir.absolutePath()) )
 106                         {
 107                                 dError("project") << "Cannot remove project data directory!";
 108                         }
 109                 }
 110                 return true;
 111         }
 112
 113         return false;
 114 }
 115
 116 ProjectManager::ProjectManager(QObject *parent)
 117  : QObject(parent), d(new Private)
 118 {
 119         d->project = new YAMF::Model::Project(this);
 120         d->project->commandManager()->setObserver(this);
 121 }
 122
 123
 124 ProjectManager::~ProjectManager()
 125 {
 126         delete d;
 127 }
 128
 129 void ProjectManager::createProject(const QString &name, const QString &author, const QString &description)
 130 {
 131         d->project->clear();
 132         d->project->setProjectName(name);
 133         d->project->setAuthor(author);
 134         d->project->setDescription(description);
 135
 136         d->project->setOpen(true);
 137 }
 138
 139 void ProjectManager::createScene(const QString &name, int frames)
 140 {
 141         if( ! d->project->isOpen() ) return;
 142
 143         YAMF::Model::Scene *scn = d->project->createScene(-1, name);
 144         YAMF::Model::Layer *lyr = scn->createLayer();
 145
 146         if( frames < 1 ) frames = 1;
 147
 148         while(frames--)
 149                 lyr->createFrame();
 150 }
 151
 152 void ProjectManager::closeProject()
 153 {
 154         d->project->clear();
 155
 156         foreach(Dash::Module *module, d->modules)
 157         {
 158                 module->reset();
 159         }
 160
 161         d->project->setOpen(false);
 162 }
 163
 164 YAMF::Model::Project *ProjectManager::project() const
 165 {
 166         return d->project;
 167 }
 168
 169 void ProjectManager::registerModule(Dash::Module *module)
 170 {
 171         d->modules << module;
 172 }
 173
 174 bool ProjectManager::aboutToRedo(const YAMF::Command::Base *command)
 175 {
 176         if( d->isLocal )
 177         {
 178                 return false;
 179         }
 180
 181         QString xml = command->toXml();
 182
 183         // TODO: Enviar por socket
 184
 185         return true;
 186 }
 187
 188 bool ProjectManager::aboutToUndo(const YAMF::Command::Base *command)
 189 {
 190         if( d->isLocal )
 191         {
 192                 return false;
 193         }
 194
 195         QString xml = command->toXml();
 196
 197         // TODO: Enviar por socket
 198
 199         return true;
 200 }
 201
 202 void ProjectManager::executed(const YAMF::Command::Base *command)
 203 {
 204         if( d->isLocal )
 205         {
 206                 Dash::CommandParser parser;
 207                 Dash::DataSource *source = parser.build(command);
 208
 209                 if( !source ) return;
 210
 211                 foreach(Dash::Module *module, d->modules)
 212                 {
 213                         if( module->sources() & source->type() )
 214                         {
 215                                 module->update(source, false);
 216                         }
 217                 }
 218
 219                 delete source;
 220
 221                 d->commandCounter++;
 222         }
 223 }
 224
 225 void ProjectManager::unexecuted(const YAMF::Command::Base *command)
 226 {
 227         if( d->isLocal )
 228         {
 229                 Dash::CommandParser parser;
 230
 231                 Dash::DataSource *source = parser.build(command);
 232
 233                 if( !source ) return;
 234
 235                 foreach(Dash::Module *module, d->modules)
 236                 {
 237                         if( module->sources() & source->type() )
 238                         {
 239                                 module->update(source, true);
 240                         }
 241                 }
 242
 243                 d->commandCounter--;
 244                 delete source;
 245         }
 246 }
 247
 248 bool ProjectManager::isModified() const
 249 {
 250         return d->commandCounter > 0;
 251 }
 252
 253 bool ProjectManager::saveProject(const QString &path)
 254 {
 255         if( d->isLocal )
 256         {
 257                 QDir projectDir = QDir::tempPath()+"/dash."+QString::number(DCore::Algorithm::random());
 258
 259                 if ( !projectDir.exists() )
 260                 {
 261                         if ( ! projectDir.mkpath(projectDir.absolutePath()) )
 262                         {
 263                                 dError() << "Cannot create: " << projectDir.absolutePath();
 264                                 return false;
 265                         }
 266                 }
 267
 268                 QString current = QDir::currentPath();
 269                 QDir::setCurrent(projectDir.absolutePath());
 270
 271                 QStringList filesToZip;
 272                 {
 273                         // Save project
 274                         QFile prj(projectDir.absolutePath()+"/project");
 275
 276                         if ( prj.open(QIODevice::WriteOnly | QIODevice::Text))
 277                         {
 278                                 QTextStream ts(&prj);
 279
 280                                 QDomDocument doc;
 281                                 doc.appendChild(d->project->toXml(doc));
 282
 283                                 ts << doc.toString();
 284
 285                                 prj.close();
 286
 287                                 QFileInfo finfo(prj);
 288                                 filesToZip << finfo.absoluteFilePath();
 289                         }
 290                 }
 291
 292                 // Save scenes
 293                 {
 294                         int index = 0;
 295                         foreach ( YAMF::Model::Scene *scene, d->project->scenes().visualValues() )
 296                         {
 297                                 QDomDocument doc;
 298                                 doc.appendChild(scene->toXml(doc));
 299
 300                                 QFile scn(projectDir.path()+"/scene"+QString::number(index));
 301
 302                                 if ( scn.open(QIODevice::WriteOnly | QIODevice::Text) )
 303                                 {
 304                                         QTextStream st(&scn);
 305                                         st << doc.toString();
 306                                         scn.close();
 307                                         index++;
 308
 309                                         QFileInfo finfo(scn);
 310                                         filesToZip << finfo.absoluteFilePath();
 311                                 }
 312                         }
 313                 }
 314
 315                 // Save library
 316                 {
 317                         QString libraryPath = projectDir.path()+"/library";
 318                         d->project->library()->save(libraryPath);
 319
 320                         filesToZip << libraryPath;
 321
 322                         QStringList dirs;
 323                         dirs << "audio" << "video" << "images" << "svg";
 324
 325                         foreach(QString dir, dirs)
 326                         {
 327                                 QString path = dir;
 328                                 if( QFile::exists(projectDir.absoluteFilePath(dir)) )
 329                                 {
 330                                         filesToZip << path;
 331                                 }
 332                         }
 333                 }
 334
 335                 DCore::Zipper zipper;
 336
 337                 D_SHOW_VAR(QDir::currentPath());
 338                 bool ok = zipper.write(filesToZip, path);
 339                 QDir::setCurrent(current);
 340
 341                 if( ! ok )
 342                         return false;
 343
 344                 d->deleteProjectDir(projectDir.absolutePath());
 345
 346                 d->commandCounter = 0;
 347
 348                 return true;
 349         }
 350
 351         // TODO: Network
 352
 353         return false;
 354 }
 355
 356 bool ProjectManager::loadProject(const QString &path)
 357 {
 358         QDir projectDir = QDir::tempPath()+"/dash."+QString::number(DCore::Algorithm::random());
 359
 360         DCore::Zipper zipper;
 361
 362         if( ! zipper.read(path, projectDir.absolutePath() ) )
 363                 return false;
 364
 365         // Load project
 366         if( projectDir.exists("project") )
 367         {
 368                 QFile prj(projectDir.absoluteFilePath("project"));
 369
 370                 if ( prj.open(QIODevice::ReadOnly | QIODevice::Text) )
 371                 {
 372                         d->project->fromXml(QString::fromLocal8Bit(prj.readAll()));
 373                         prj.close();
 374                 }
 375         }
 376
 377         // Cargar libreria!
 378         {
 379                 d->project->loadLibrary(projectDir.path()+"/library");
 380         }
 381
 382         // Load scenes
 383         {
 384                 QStringList scenes = projectDir.entryList(QStringList() << "scene*", QDir::Readable | QDir::Files);
 385
 386                 foreach(QString scenePath, scenes)
 387                 {
 388                         scenePath = projectDir.absoluteFilePath(scenePath);
 389                         YAMF::Model::Scene *scene = d->project->createScene();
 390
 391                         QFile f(scenePath);
 392
 393                         if ( f.open(QIODevice::ReadOnly | QIODevice::Text) )
 394                         {
 395                                 QString xml = QString::fromLocal8Bit(f.readAll());
 396                                 scene->fromXml(xml);
 397
 398                                 f.close();
 399                         }
 400                 }
 401         }
 402
 403         d->commandCounter = 0;
 404         d->project->setOpen(true);
 405         d->deleteProjectDir(projectDir.absolutePath());
 406
 407         return true;
 408 }
 409
 410