Source/command/dceditcommands.cpp

   1 //  Copyright (c) 2012 Dennco Project
   2 //
   3 // This program is free software: you can redistribute it and/or modify
   4 // it under the terms of the GNU General Public License as published by
   5 // the Free Software Foundation, either version 3 of the License, or
   6 // (at your option) any later version.
   7 //
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 //
  17 //  Created by tkawata on Sep-30, 2012.
  18 //
  19 #include "dceditcommands.h"
  20
  21 #include "dccreator.h"
  22 #include "dcscene.h"
  23
  24 #include "dccontainer.h"
  25 #include "dccell.h"
  26 #include "dccellcode.h"
  27 #include "dcaxon.h"
  28 #include "dcaxonterminal.h"
  29 #include "dcreceptor.h"
  30 #include "dcvpagecomponent.h"
  31 #include "dcvccellcode.h"
  32 #include "utils/dcskeltoncreatorutil.h"
  33
  34 #include "dctreeviewwidget.h"
  35
  36 // -----------------------------
  37 DCStartAddAxonTerminalCommandFromAxon::DCStartAddAxonTerminalCommandFromAxon(const void *requester, DCCreator *creator, DCCell *ownerCell)
  38     : DCCommand(requester, creator), d_ownerCell(ownerCell)
  39 {
  40
  41 }
  42
  43 void DCStartAddAxonTerminalCommandFromAxon::redo()
  44 {
  45     DCAxon *axon = d_ownerCell->getAxon();
  46     bool r = getScene()->startTerminalEditForAxon(getRequester(), axon);
  47     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
  48
  49 }
  50
  51 void DCStartAddAxonTerminalCommandFromAxon::undo()
  52 {
  53     getScene()->finishTerminalEdit(getRequester());
  54 }
  55
  56
  57 // -----------------------------
  58 DCStartAddAxonTerminalCommandFromReceptor::DCStartAddAxonTerminalCommandFromReceptor(const void *requester, DCCreator *creator, DCCell *ownerCell, const QString &receptorName)
  59     : DCCommand(requester, creator), d_ownerCell(ownerCell), d_receptorName(receptorName)
  60 {
  61
  62 }
  63
  64 void DCStartAddAxonTerminalCommandFromReceptor::redo()
  65 {
  66     DCReceptor *receptor = d_ownerCell->createReceptor(d_receptorName);
  67     bool r = getScene()->startTerminalEditForReceptor(getRequester(), receptor);
  68     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
  69 }
  70
  71 void DCStartAddAxonTerminalCommandFromReceptor::undo()
  72 {
  73     getScene()->finishTerminalEdit(getRequester());
  74     d_ownerCell->removeReceptor(d_receptorName);
  75 }
  76
  77
  78 // -----------------------------
  79 DCCommitAddAxonTerminalCommand::DCCommitAddAxonTerminalCommand(const void *requester, DCCreator *creator, DCAxon *axon, DCCell *receptorCell, const QString &receptorName)
  80     : DCCommand(requester, creator), d_receptorCell(receptorCell),d_receptor(NULL), d_receptorName(receptorName), d_isAdded(false)
  81 {
  82     d_axonCell = axon->getOwnerCell();
  83 }
  84
  85 DCCommitAddAxonTerminalCommand::DCCommitAddAxonTerminalCommand(const void *requester, DCCreator *creator, DCCell *axonCell, DCReceptor *receptor)
  86     : DCCommand(requester, creator), d_axonCell(axonCell), d_receptor(receptor), d_receptorName(""), d_isAdded(false)
  87 {
  88     d_receptorCell = dynamic_cast<DCCell*>(d_receptor->getOwnerCell());
  89 }
  90
  91 void DCCommitAddAxonTerminalCommand::redo()
  92 {
  93     bool r = false;
  94     if (!d_receptor)
  95     {
  96         d_isAdded = d_axonCell->connectTo(d_receptorName.toStdString(), d_receptorCell);
  97         r = getScene()->finishTerminalEdit(getRequester());
  98     }
  99     else
 100     {
 101         TKAxonTerminal *terminal = d_axonCell->getAxon()->addTerminal();
 102         if (terminal)
 103         {
 104             d_receptor->setTarget(terminal);
 105             d_isAdded = true;
 106         }
 107         r = getScene()->finishTerminalEdit(getRequester());
 108     }
 109     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 110 }
 111
 112 void DCCommitAddAxonTerminalCommand::undo()
 113 {
 114     if (!d_isAdded)
 115         return;
 116
 117     if (!d_receptor)
 118     {
 119         DCAxon *axon = dynamic_cast <DCAxon*>(d_axonCell->getAxon());
 120         DCReceptor *receptor = d_receptorCell->getReceptor(d_receptorName);
 121         if (axon && receptor)
 122         {
 123             DCAxonTerminal *terminal = dynamic_cast<DCAxonTerminal*>(receptor->getTarget());
 124             d_receptorCell->removeReceptor(d_receptorName);
 125             axon->removeAxonTerminal(terminal);
 126         }
 127     }
 128     else
 129     {
 130         DCAxon *axon = dynamic_cast <DCAxon*>(d_axonCell->getAxon());
 131         QString receptorName = QString::fromStdString(d_receptorCell->getReceptorName(d_receptor));
 132         DCAxonTerminal *terminal = dynamic_cast<DCAxonTerminal*>(d_receptor->getTarget());
 133
 134         d_receptorCell->removeReceptor(receptorName);
 135         axon->removeAxonTerminal(terminal);
 136     }
 137
 138 }
 139
 140
 141 DCRemoveAxonTerminalCommand::DCRemoveAxonTerminalCommand(const void *requester, DCCreator *creator, DCCell *axonCell, DCAxonTerminal *terminal)
 142     : DCCommand(requester, creator), d_cell(axonCell), d_axonTerminal(terminal), d_receptorName(""), d_isDeleted(false)
 143 {
 144
 145 }
 146
 147 DCRemoveAxonTerminalCommand::DCRemoveAxonTerminalCommand(const void *requester, DCCreator *creator, DCCell *receptorCell, const QString &receptorName)
 148     : DCCommand(requester, creator), d_cell(receptorCell), d_axonTerminal(NULL), d_receptorName(receptorName), d_isDeleted(false)
 149 {
 150
 151 }
 152
 153 void DCRemoveAxonTerminalCommand::redo()
 154 {
 155     bool r = false;
 156     if (d_axonTerminal)
 157     {
 158         //delete from axon terminal
 159         DCReceptor *receptor = dynamic_cast<DCReceptor*>(d_axonTerminal->getTarget());
 160         DCAxon *axon = dynamic_cast <DCAxon*>(d_axonTerminal->getOwner());
 161         if (receptor && axon)
 162         {
 163             DCCell *targetCell = dynamic_cast<DCCell*>(receptor->getOwnerCell());
 164             QString receptorName = QString::fromStdString(targetCell->getReceptorName(receptor));
 165             d_isDeleted = targetCell->removeReceptor(receptorName);
 166             if (d_isDeleted)
 167                 r = axon->removeAxonTerminal(d_axonTerminal);
 168         }
 169     }
 170     else
 171     {
 172         //delete from receptor name
 173         DCReceptor *receptor = d_cell->getReceptor(d_receptorName);
 174         DCAxonTerminal *terminal = dynamic_cast<DCAxonTerminal*>(receptor->getTarget());
 175         DCAxon *axon = dynamic_cast<DCAxon*>(terminal->getOwner());
 176         d_isDeleted = d_cell->removeReceptor(d_receptorName);
 177         if (d_isDeleted)
 178             r = axon->removeAxonTerminal(terminal);
 179     }
 180     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 181 }
 182
 183 void DCRemoveAxonTerminalCommand::undo()
 184 {
 185     qDebug() << "TODO undo DCDeleteAxonTermianlCommand";
 186     //TODO
 187 }
 188
 189
 190 DCStartCellCodeEditCommand::DCStartCellCodeEditCommand(const void *requester, DCCreator *creator, DCCell *ownerCell)
 191     : DCCommand(requester, creator), d_cell(ownerCell)
 192 {
 193
 194 }
 195
 196 void DCStartCellCodeEditCommand::redo()
 197 {
 198     bool r =getScene()->startCellCodeEdit(getRequester(), d_cell);
 199     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 200 }
 201
 202 void DCStartCellCodeEditCommand::undo()
 203 {
 204
 205 }
 206
 207
 208 DCFinishCellCodeEditCommand::DCFinishCellCodeEditCommand(const void *requester, DCCreator *creator)
 209     : DCCommand(requester, creator)
 210 {
 211
 212 }
 213
 214 void DCFinishCellCodeEditCommand::redo()
 215 {
 216     bool r = getScene()->finishCellCodeEdit(getRequester());
 217     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 218 }
 219
 220 void DCFinishCellCodeEditCommand::undo()
 221 {
 222
 223 }
 224
 225
 226 /*--------------------------------*/
 227 DCAssignCellCodeClassToCellCommand::DCAssignCellCodeClassToCellCommand(const void *requester, DCCreator *creator, DCCell *cell, DCCellCode *cellCode)
 228     : DCCommand(requester, creator), d_cell(cell), d_cellCode(cellCode), d_prevClass(NULL)
 229 {
 230
 231 }
 232
 233 void DCAssignCellCodeClassToCellCommand::redo()
 234 {
 235     bool r = false;
 236     if (d_cell)
 237     {
 238         d_prevClass = d_cell->getCellCode();
 239         r = d_cell->setCellCode(d_cellCode, NULL);
 240     }
 241     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 242 }
 243
 244 void DCAssignCellCodeClassToCellCommand::undo()
 245 {
 246     if (d_cell && d_prevClass)
 247     {
 248         d_cell->setCellCode(d_prevClass, NULL);
 249     }
 250
 251 }
 252
 253
 254 /*--------------------------------*/
 255 DCUnassignCellCodeClassFromCellCommand::DCUnassignCellCodeClassFromCellCommand(const void *requester, DCCreator *creator, DCCell *cell)
 256     : DCCommand(requester, creator), d_cell(cell), d_prevClass(NULL)
 257 {
 258
 259 }
 260
 261 void DCUnassignCellCodeClassFromCellCommand::redo()
 262 {
 263     bool r = false;
 264     if (d_cell)
 265     {
 266         d_prevClass = d_cell->getCellCode();
 267         r = d_cell->setCellCode(getContainer()->getEmptyCellCodeClass(), NULL);
 268     }
 269     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 270 }
 271
 272 void DCUnassignCellCodeClassFromCellCommand::undo()
 273 {
 274     if (d_cell && d_prevClass)
 275     {
 276         d_cell->setCellCode(d_prevClass, NULL);
 277     }
 278
 279 }
 280
 281
 282 /*--------------------------------*/
 283
 284 DCAddCellCodeClassCommand::DCAddCellCodeClassCommand(const void *requester, DCCreator *creator, DCContainer *container, const QString &name, const QString &type)
 285     : DCCommand(requester, creator), d_container(container), d_name(name), d_type(type)
 286 {
 287
 288 }
 289
 290 void DCAddCellCodeClassCommand::redo()
 291 {
 292     bool r = d_container->addCellCode(d_name.toStdString(), d_type.toStdString(), DCSkeltonCreatorUtil::getDefaultCellCodeClassScript().toStdString()) != NULL;
 293     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 294 }
 295
 296 void DCAddCellCodeClassCommand::undo()
 297 {
 298 }
 299
 300 /*--------------------------------*/
 301
 302 DCMoveCellCodeClassCommand::DCMoveCellCodeClassCommand(const void *requester, DCCreator *creator, const QString &name, const QString &type)
 303     : DCCommand(requester, creator), d_name(name), d_type(type)
 304 {
 305 }
 306
 307 DCMoveCellCodeClassCommand::~DCMoveCellCodeClassCommand()
 308 {
 309 }
 310
 311 void DCMoveCellCodeClassCommand::redo()
 312 {
 313
 314 }
 315
 316 void DCMoveCellCodeClassCommand::undo()
 317 {
 318
 319 }
 320
 321
 322 /*--------------------------------*/
 323
 324 DCChangeCellCodeClassTypeCommand::DCChangeCellCodeClassTypeCommand(const void *requester, DCCreator *creator, DCCellCode *cellCode, const QString& newType)
 325     : DCCommand(requester, creator), d_cellCode(cellCode), d_type(newType)
 326 {
 327
 328 }
 329
 330 void DCChangeCellCodeClassTypeCommand::redo()
 331 {
 332     bool r = false;
 333     if (getContainer()->getIsScriptable(d_type))
 334     {
 335         d_cellCode->changeType(d_type);
 336     }
 337     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 338 }
 339
 340 void DCChangeCellCodeClassTypeCommand::undo()
 341 {
 342
 343 }
 344
 345
 346 /*--------------------------------*/
 347
 348 DCRemoveCellCodeClassCommand::DCRemoveCellCodeClassCommand(const void *requester, DCCreator *creator, DCContainer *container, DCCellCode *cellCode)
 349     : DCCommand(requester, creator), d_container(container)
 350 {
 351     d_cellCodes.append(cellCode);
 352 }
 353
 354 DCRemoveCellCodeClassCommand::DCRemoveCellCodeClassCommand(const void *requester, DCCreator *creator, DCContainer *container, const QList<DCCellCode *> &cellcodes)
 355     : DCCommand(requester, creator), d_container(container), d_cellCodes(cellcodes)
 356 {
 357 }
 358
 359 DCRemoveCellCodeClassCommand::~DCRemoveCellCodeClassCommand()
 360 {
 361 }
 362
 363 void DCRemoveCellCodeClassCommand::redo()
 364 {
 365     bool r = false;
 366
 367     for (int i = 0; i < d_cellCodes.length(); i++)
 368     {
 369         if (!d_container->removeCellCode(d_cellCodes.at(i)))
 370         {
 371             r = false;
 372         }
 373     }
 374
 375     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 376 }
 377
 378 void DCRemoveCellCodeClassCommand::undo()
 379 {
 380
 381 }
 382
 383 /*--------------------------------*/
 384
 385 DCAddCellCommand::DCAddCellCommand(const void *requester, DCCreator *creator, DCContainer *container, const QString &path, const QString &name, const QString &type, float pageX, float pageY)
 386     : DCCommand(requester, creator), d_container(container), d_path(path), d_name(name), d_type(type), d_pageX(pageX), d_pageY(pageY)
 387 {
 388
 389 }
 390
 391 void DCAddCellCommand::redo()
 392 {
 393     bool r = false;
 394
 395     DCCell *cell = NULL;
 396     if (d_container->getIsScriptable(d_type))
 397         cell = dynamic_cast<DCCell*>(d_container->addCell(d_path.toStdString(), d_name.toStdString(), d_type.toStdString(), DCSkeltonCreatorUtil::getDefaultCustomScript().toStdString()));
 398     else
 399         cell = dynamic_cast<DCCell*>(d_container->addCell(d_path.toStdString(), d_name.toStdString(), d_type.toStdString(), ""));
 400
 401     if (cell)
 402     {
 403         r = true;
 404         cell->setViewPageX(d_pageX);
 405         cell->setViewPageY(d_pageY);
 406         cell->getVComponent()->setSelected(true,true);
 407         getController()->selectPage(this, cell->getPageBelonging(), false);
 408         if (getController()->getPersMode() != DCCreator::DC_PERSMODE_PAGEEDIT)
 409         {
 410             getController()->changePersMode(this, DCCreator::DC_PERSMODE_PAGEEDIT);
 411         }
 412     }
 413     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 414 }
 415
 416 void DCAddCellCommand::undo()
 417 {
 418
 419 }
 420
 421 /*--------------------------------*/
 422
 423 DCChangeCellTypeCommand::DCChangeCellTypeCommand(const void *requester, DCCreator *creator, DCCell* cell, const QString &newType)
 424     : DCCommand(requester, creator), d_cell(cell), d_type(newType)
 425 {
 426
 427 }
 428
 429 void DCChangeCellTypeCommand::redo()
 430 {
 431     bool r = false;
 432     if (d_cell)
 433     {
 434         if (!getContainer()->getIsScriptable(d_type))
 435         {
 436             d_cell->setCellCode(getContainer()->getEmptyCellCodeClass(), NULL);
 437             d_cell->saveCustomScript("");
 438         }
 439
 440         if (d_cell->getIsCellCodeClassAssgined())
 441         {
 442             //TODO
 443         }
 444         else
 445         {
 446             d_cell->changeType(d_type);
 447             r = true;
 448         }
 449     }
 450     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 451 }
 452
 453 void DCChangeCellTypeCommand::undo()
 454 {
 455
 456 }
 457
 458 /*--------------------------------*/
 459
 460 DCRenameCellCommand::DCRenameCellCommand(const void *requester, DCCreator *creator, DCCell *cell, const QString &newName)
 461     : DCCommand(requester, creator), d_cell(cell), d_name(newName)
 462 {
 463     d_location = QString::fromStdString(cell->getLocation());
 464 }
 465
 466 DCRenameCellCommand::DCRenameCellCommand(const void *requester, DCCreator *creator, DCCell *cell, const QString &newLocation, const QString &newName)
 467     : DCCommand(requester, creator), d_cell(cell), d_location(newLocation), d_name(newName)
 468 {
 469
 470 }
 471
 472 DCRenameCellCommand::~DCRenameCellCommand()
 473 {
 474
 475 }
 476
 477 void DCRenameCellCommand::redo()
 478 {
 479     bool r = false;
 480     if (getContainer())
 481     {
 482         if (d_location != QString::fromStdString(d_cell->getLocation()))
 483         {
 484             DCVCPage *page = getScene()->getPage(d_location.toStdString());
 485             if (page)
 486             {
 487                 d_cell->getVComponent()->changePageBelonging(page);
 488                 r = getContainer()->moveCell(d_cell, d_location);
 489             }
 490         }
 491         else
 492         {
 493             r = true;
 494         }
 495         if (r)
 496             r = getContainer()->renameCell(d_cell, d_name);
 497     }
 498
 499     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 500 }
 501
 502 void DCRenameCellCommand::undo()
 503 {
 504
 505 }
 506
 507 /*--------------------------------*/
 508
 509 DCMoveCellCommand::DCMoveCellCommand(const void *requester, DCCreator *creator, DCCell *cell, DCVCPage *newPage)
 510     : DCCommand(requester, creator), d_cell(cell), d_page(newPage)
 511 {
 512 }
 513
 514 DCMoveCellCommand::~DCMoveCellCommand()
 515 {
 516
 517 }
 518
 519 void DCMoveCellCommand::redo()
 520 {
 521     bool r = false;
 522
 523     if (d_page && d_cell)
 524     {
 525         d_cell->getVComponent()->changePageBelonging(d_page);
 526         r = true;
 527     }
 528
 529     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 530 }
 531
 532 void DCMoveCellCommand::undo()
 533 {
 534
 535 }
 536
 537 /*--------------------------------*/
 538
 539 DCRemoveCellCommand::DCRemoveCellCommand(const void *requester, DCCreator *creator, DCContainer *container, DCCell* cell)
 540     : DCCommand(requester, creator), d_container(container)
 541 {
 542     d_cells.append(cell);
 543 }
 544
 545 DCRemoveCellCommand::DCRemoveCellCommand(const void *requester, DCCreator *creator, DCContainer *container, const QList<DCCell*> &cells)
 546     : DCCommand(requester, creator), d_container(container), d_cells(cells)
 547 {
 548 }
 549
 550 DCRemoveCellCommand::~DCRemoveCellCommand()
 551 {
 552
 553 }
 554
 555 void DCRemoveCellCommand::redo()
 556 {
 557     bool r = true;
 558     for (int i = 0; i < d_cells.length(); i++)
 559     {
 560         if (!d_container->removeCell(d_cells.at(i)))
 561         {
 562             r = false;
 563         }
 564     }
 565     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 566 }
 567
 568 void DCRemoveCellCommand::undo()
 569 {
 570
 571 }
 572
 573 /*--------------------------------*/
 574 DCAddPageCommand::DCAddPageCommand(const void *requester, DCCreator *creator, const QString &containerBasedPath)
 575     : DCCommand(requester, creator), d_path(containerBasedPath), d_page(NULL)
 576 {
 577
 578 }
 579
 580 void DCAddPageCommand::redo()
 581 {
 582     if (!getController())
 583         return;
 584
 585     DCTreeViewWidget::selectWhenFilePathAdded(getContainer()->containerBasedPathToSysFilePath(d_path));
 586     d_page = getScene()->addPage(d_path.toStdString());
 587     bool r = getController()->savePage(d_page);
 588     getController()->selectPage(getRequester(), d_page, false);
 589     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 590 }
 591
 592 void DCAddPageCommand::undo()
 593 {
 594
 595 }
 596
 597 /*--------------------------------*/
 598 DCMovePageCommand::DCMovePageCommand(const void *requester, DCCreator *creator, const QString &oldContainerBasedPathName, const QString &newContainerBasedPathName)
 599     : DCCommand(requester, creator), d_oldPath(oldContainerBasedPathName), d_newPath(newContainerBasedPathName)
 600 {
 601 }
 602
 603 DCMovePageCommand::~DCMovePageCommand()
 604 {
 605     qDebug() << "DCRenamePageCommand removed..";
 606 }
 607
 608 void DCMovePageCommand::redo()
 609 {
 610     bool r = false;
 611
 612     DCVCPage *oldPage = getScene()->getPage(d_oldPath.toStdString());
 613     if (getContainer() && oldPage && !getScene()->getIsPageExist(d_newPath.toStdString()))
 614     {
 615         DCTreeViewWidget::selectWhenFilePathAdded(getContainer()->containerBasedPathToSysFilePath(d_newPath));
 616         DCVCPage *newPage = getContainer()->movePage(d_oldPath, d_newPath);
 617         getController()->selectPage(getRequester(), newPage, false);
 618
 619         if (newPage)
 620         {
 621             r = getController()->saveAll(false);
 622         }
 623         else
 624         {
 625             //TODO show error message?
 626             DCTreeViewWidget::selectWhenFilePathAdded("");
 627         }
 628     }
 629     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 630 }
 631
 632 void DCMovePageCommand::undo()
 633 {
 634
 635 }
 636
 637
 638 /*--------------------------------*/
 639 DCRemovePageCommand::DCRemovePageCommand(const void *requester, DCCreator *creator, DCVCPage *page)
 640     : DCCommand(requester, creator), d_page(page)
 641 {
 642
 643 }
 644
 645 DCRemovePageCommand::~DCRemovePageCommand()
 646 {
 647     qDebug() << "DCRemovePageCommand removed..";
 648 }
 649
 650 void DCRemovePageCommand::redo()
 651 {
 652     bool r = false;
 653
 654     if (!getContainer())
 655     {
 656         setCommandResult(DCCommand::DCCOMMAND_FAILED);
 657         return;
 658     }
 659
 660     const QList<DCVPageComponent*> *vcells = d_page->getCells();
 661     const QList<DCVPageComponent*> *vcellCodeClasses = d_page->getCellCodeClasses();
 662
 663     QList<DCCellCode*> cellcodes;
 664     for (int i = 0; i < vcellCodeClasses->length(); i++)
 665     {
 666         DCCellCode *cellCode = dynamic_cast<DCVCCellCode*>(vcellCodeClasses->at(i))->getOwnerCellCodeClass();
 667         if (cellCode)
 668             cellcodes.append(cellCode);
 669     }
 670
 671     if (cellcodes.length()>0)
 672     {
 673         DCCommand *command = new DCRemoveCellCodeClassCommand(getRequester(), getController(), getContainer(), cellcodes);
 674         d_undoStack.push(command);
 675
 676         if (command->getCommandResult() != DCCommand::DCCOMMAND_SUCCEEDED)
 677             r = false;
 678     }
 679
 680     QList<DCCell*> cells;
 681     for (int i = 0; i < vcells->length(); i++)
 682     {
 683         DCCell *cell = vcells->at(i)->getOwnerCell();
 684         if (cell)
 685             cells.append(cell);
 686     }
 687
 688     if (cells.length()>0)
 689     {
 690         DCCommand *command = new DCRemoveCellCommand(getRequester(), getController(), getContainer(), cells);
 691         d_undoStack.push(command);
 692
 693         if (command->getCommandResult() != DCCommand::DCCOMMAND_SUCCEEDED)
 694             r = false;
 695     }
 696
 697     QString filePath = QString::fromStdString(getContainer()->getContainerRootPath());
 698     filePath.append(d_page->getLocationPath());
 699
 700     QString sceneSettingFilePath = getScene()->getSceneSettingFilePathForPage(d_page);
 701
 702     QDir dir;
 703     if (!dir.remove(filePath))
 704     {
 705         r = false;
 706     }
 707     dir.remove(sceneSettingFilePath);
 708
 709     if (!getScene()->removePage(d_page))
 710     {
 711         r = false;
 712     }
 713
 714     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 715 }
 716
 717 void DCRemovePageCommand::undo()
 718 {
 719
 720 }
 721
 722 /*--------------------------------*/
 723 DCAddDirectoryCommand::DCAddDirectoryCommand(const void *requester, DCCreator *creator, const QString &sysFilePath)
 724     : DCCommand(requester, creator), d_path(sysFilePath)
 725 {
 726
 727 }
 728
 729 void DCAddDirectoryCommand::redo()
 730 {
 731     bool r = DCTreeViewWidget::addDirectory(d_path);
 732     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 733 }
 734
 735 void DCAddDirectoryCommand::undo()
 736 {
 737
 738 }
 739
 740 /*--------------------------------*/
 741 DCRenameDirectoryCommand::DCRenameDirectoryCommand(const void *requester, DCCreator *creator, const QString &sysOldFilePath, const QString &sysNewFilePath)
 742     : DCCommand(requester, creator), d_oldPath(sysOldFilePath), d_newPath(sysNewFilePath)
 743 {
 744
 745 }
 746
 747 void DCRenameDirectoryCommand::redo()
 748 {
 749     DCTreeViewWidget::selectWhenFilePathAdded(d_newPath);
 750     bool r = moveComponentsToDirectory(d_oldPath, d_newPath);
 751     if (r)
 752     {
 753         DCTreeViewWidget::removeDirectory(d_oldPath);
 754     }
 755     else
 756     {
 757         //TODO show error message?
 758         DCTreeViewWidget::selectWhenFilePathAdded("");
 759     }
 760     getController()->saveAll(false);
 761 }
 762
 763 void DCRenameDirectoryCommand::undo()
 764 {
 765
 766 }
 767
 768 bool DCRenameDirectoryCommand::moveComponentsToDirectory(const QString &orgSysDirectory, const QString &destSysDirectory)
 769 {
 770     if (QDir(destSysDirectory).exists())
 771         return false;
 772
 773     QDir dir;
 774     if (!dir.mkpath(destSysDirectory))
 775         return false;
 776
 777     bool r = true;
 778     QDir orgDir(orgSysDirectory);
 779     QFileInfoList list = orgDir.entryInfoList(QDir::NoDot | QDir::NoDotDot | QDir::AllEntries);
 780     for (int i = 0; r && i < list.size(); i++)
 781     {
 782         QFileInfo fileInfo = list.at(i);
 783         if (fileInfo.isDir())
 784         {
 785             QDir d(fileInfo.absoluteFilePath());
 786             QString newDir = destSysDirectory + "/" + d.dirName();
 787             r = moveComponentsToDirectory(fileInfo.absoluteFilePath(), newDir);
 788         }
 789         else
 790         {
 791             QString newFile = destSysDirectory + "/" + fileInfo.fileName();
 792             QDir newFileDir(newFile);
 793             if (!newFileDir.exists())
 794             {
 795                 QString oldFileContainerBasedPath = getContainer()->sysFilePathToContainerBasedPath(fileInfo.absoluteFilePath());
 796                 QString newFileContainerBasedPath = getContainer()->sysFilePathToContainerBasedPath(newFile);
 797                 if (getScene()->getIsPageExist(oldFileContainerBasedPath))
 798                 {
 799                     r = getContainer()->movePage(oldFileContainerBasedPath, newFileContainerBasedPath) != NULL;
 800                 }
 801                 else
 802                 {
 803                     QFile oldFile(fileInfo.absoluteFilePath());
 804                     if (oldFile.exists())
 805                     {
 806                         r = oldFile.copy(newFile);
 807                         if (r)
 808                         {
 809                             oldFile.remove();
 810                         }
 811                     }
 812                 }
 813             }
 814         }
 815     }
 816     return r;
 817 }
 818
 819
 820 /*--------------------------------*/
 821 DCRemoveDirectoryCommand::DCRemoveDirectoryCommand(const void *requester, DCCreator *creator, const QString &sysFilePath)
 822     : DCCommand(requester, creator), d_path(sysFilePath)
 823 {
 824
 825 }
 826
 827 void DCRemoveDirectoryCommand::redo()
 828 {
 829     bool r = DCTreeViewWidget::removeDirectory(d_path);
 830     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 831 }
 832
 833 void DCRemoveDirectoryCommand::undo()
 834 {
 835
 836 }
 837
 838 /*--------------------------------*/
 839 DCRenameReceptorNameCommand::DCRenameReceptorNameCommand(const void *requester, DCCreator *creator, DCCell *cell, const QString &oldName, const QString &newName)
 840     : DCCommand(requester, creator), d_cell(cell), d_oldName(oldName), d_newName(newName)
 841 {
 842
 843 }
 844
 845 void DCRenameReceptorNameCommand::redo()
 846 {
 847     bool r = d_cell->renameReceptor(d_oldName, d_newName);
 848     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 849 }
 850
 851 void DCRenameReceptorNameCommand::undo()
 852 {
 853
 854 }