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