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 DCRemoveCellCodeClassCommand::DCRemoveCellCodeClassCommand(const void *requester, DCCreator *creator, DCContainer *container, DCCellCode *cellCode)
 323     : DCCommand(requester, creator), d_container(container)
 324 {
 325     d_cellCodes.append(cellCode);
 326 }
 327
 328 DCRemoveCellCodeClassCommand::DCRemoveCellCodeClassCommand(const void *requester, DCCreator *creator, DCContainer *container, const QList<DCCellCode *> &cellcodes)
 329     : DCCommand(requester, creator), d_container(container), d_cellCodes(cellcodes)
 330 {
 331 }
 332
 333 DCRemoveCellCodeClassCommand::~DCRemoveCellCodeClassCommand()
 334 {
 335 }
 336
 337 void DCRemoveCellCodeClassCommand::redo()
 338 {
 339     bool r = false;
 340
 341     for (int i = 0; i < d_cellCodes.length(); i++)
 342     {
 343         if (!d_container->removeCellCode(d_cellCodes.at(i)))
 344         {
 345             r = false;
 346         }
 347     }
 348
 349     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 350 }
 351
 352 void DCRemoveCellCodeClassCommand::undo()
 353 {
 354
 355 }
 356
 357 /*--------------------------------*/
 358
 359 DCAddCellCommand::DCAddCellCommand(const void *requester, DCCreator *creator, DCContainer *container, const QString &path, const QString &name, const QString &type)
 360     : DCCommand(requester, creator), d_container(container), d_path(path), d_name(name), d_type(type)
 361 {
 362
 363 }
 364
 365 void DCAddCellCommand::redo()
 366 {
 367     bool r = false;
 368
 369     DCCell *cell = dynamic_cast<DCCell*>(d_container->addCell(d_path.toStdString(), d_name.toStdString(), d_type.toStdString(), ""));
 370     if (cell)
 371     {
 372         r = true;
 373         cell->getVComponent()->setSelected(true,true);
 374         getController()->selectPage(this, cell->getPageBelonging(), false);
 375         if (getController()->getPersMode() != DCCreator::DC_PERSMODE_PAGEEDIT)
 376         {
 377             getController()->changePersMode(this, DCCreator::DC_PERSMODE_PAGEEDIT);
 378         }
 379     }
 380     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 381 }
 382
 383 void DCAddCellCommand::undo()
 384 {
 385
 386 }
 387
 388 /*--------------------------------*/
 389
 390 DCRenameCellCommand::DCRenameCellCommand(const void *requester, DCCreator *creator, DCCell *cell, const QString &newName)
 391     : DCCommand(requester, creator), d_cell(cell), d_name(newName)
 392 {
 393
 394 }
 395
 396 DCRenameCellCommand::~DCRenameCellCommand()
 397 {
 398
 399 }
 400
 401 void DCRenameCellCommand::redo()
 402 {
 403     bool r = false;
 404     if (getContainer())
 405         r = getContainer()->renameCell(d_cell, d_name);
 406
 407     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 408 }
 409
 410 void DCRenameCellCommand::undo()
 411 {
 412
 413 }
 414
 415 /*--------------------------------*/
 416
 417 DCMoveCellCommand::DCMoveCellCommand(const void *requester, DCCreator *creator, DCCell *cell, DCVCPage *newPage)
 418     : DCCommand(requester, creator), d_cell(cell), d_page(newPage)
 419 {
 420 }
 421
 422 DCMoveCellCommand::~DCMoveCellCommand()
 423 {
 424
 425 }
 426
 427 void DCMoveCellCommand::redo()
 428 {
 429     bool r = false;
 430
 431     if (d_page && d_cell)
 432     {
 433         d_cell->getVComponent()->changePageBelonging(d_page);
 434         r = true;
 435     }
 436
 437     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 438 }
 439
 440 void DCMoveCellCommand::undo()
 441 {
 442
 443 }
 444
 445 /*--------------------------------*/
 446
 447 DCRemoveCellCommand::DCRemoveCellCommand(const void *requester, DCCreator *creator, DCContainer *container, DCCell* cell)
 448     : DCCommand(requester, creator), d_container(container)
 449 {
 450     d_cells.append(cell);
 451 }
 452
 453 DCRemoveCellCommand::DCRemoveCellCommand(const void *requester, DCCreator *creator, DCContainer *container, const QList<DCCell*> &cells)
 454     : DCCommand(requester, creator), d_container(container), d_cells(cells)
 455 {
 456 }
 457
 458 DCRemoveCellCommand::~DCRemoveCellCommand()
 459 {
 460
 461 }
 462
 463 void DCRemoveCellCommand::redo()
 464 {
 465     bool r = true;
 466     for (int i = 0; i < d_cells.length(); i++)
 467     {
 468         if (!d_container->removeCell(d_cells.at(i)))
 469         {
 470             r = false;
 471         }
 472     }
 473     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 474 }
 475
 476 void DCRemoveCellCommand::undo()
 477 {
 478
 479 }
 480
 481 /*--------------------------------*/
 482 DCAddPageCommand::DCAddPageCommand(const void *requester, DCCreator *creator, const QString &containerBasedPath)
 483     : DCCommand(requester, creator), d_path(containerBasedPath), d_page(NULL)
 484 {
 485
 486 }
 487
 488 void DCAddPageCommand::redo()
 489 {
 490     if (!getController())
 491         return;
 492
 493     DCTreeViewWidget::selectWhenFilePathAdded(getContainer()->containerBasedPathToSysFilePath(d_path));
 494     d_page = getScene()->addPage(d_path.toStdString());
 495     bool r = getController()->savePage(d_page);
 496     getController()->selectPage(getRequester(), d_page, false);
 497     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 498 }
 499
 500 void DCAddPageCommand::undo()
 501 {
 502
 503 }
 504
 505 /*--------------------------------*/
 506 DCMovePageCommand::DCMovePageCommand(const void *requester, DCCreator *creator, const QString &oldContainerBasedPathName, const QString &newContainerBasedPathName)
 507     : DCCommand(requester, creator), d_oldPath(oldContainerBasedPathName), d_newPath(newContainerBasedPathName)
 508 {
 509 }
 510
 511 DCMovePageCommand::~DCMovePageCommand()
 512 {
 513     qDebug() << "DCRenamePageCommand removed..";
 514 }
 515
 516 void DCMovePageCommand::redo()
 517 {
 518     bool r = false;
 519
 520     DCVCPage *oldPage = getScene()->getPage(d_oldPath.toStdString());
 521     if (getContainer() && oldPage && !getScene()->getIsPageExist(d_newPath.toStdString()))
 522     {
 523         DCTreeViewWidget::selectWhenFilePathAdded(getContainer()->containerBasedPathToSysFilePath(d_newPath));
 524         DCVCPage *newPage = getContainer()->movePage(d_oldPath, d_newPath);
 525         getController()->selectPage(getRequester(), newPage, false);
 526
 527         if (newPage)
 528         {
 529             r = getController()->saveAll(false);
 530         }
 531         else
 532         {
 533             //TODO show error message?
 534             DCTreeViewWidget::selectWhenFilePathAdded("");
 535         }
 536     }
 537     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 538 }
 539
 540 void DCMovePageCommand::undo()
 541 {
 542
 543 }
 544
 545
 546 /*--------------------------------*/
 547 DCRemovePageCommand::DCRemovePageCommand(const void *requester, DCCreator *creator, DCVCPage *page)
 548     : DCCommand(requester, creator), d_page(page)
 549 {
 550
 551 }
 552
 553 DCRemovePageCommand::~DCRemovePageCommand()
 554 {
 555     qDebug() << "DCRemovePageCommand removed..";
 556 }
 557
 558 void DCRemovePageCommand::redo()
 559 {
 560     bool r = false;
 561
 562     if (!getContainer())
 563     {
 564         setCommandResult(DCCommand::DCCOMMAND_FAILED);
 565         return;
 566     }
 567
 568     const QList<DCVPageComponent*> *vcells = d_page->getCells();
 569     const QList<DCVPageComponent*> *vcellCodeClasses = d_page->getCellCodeClasses();
 570
 571     QList<DCCellCode*> cellcodes;
 572     for (int i = 0; i < vcellCodeClasses->length(); i++)
 573     {
 574         DCCellCode *cellCode = dynamic_cast<DCVCCellCode*>(vcellCodeClasses->at(i))->getOwnerCellCodeClass();
 575         if (cellCode)
 576             cellcodes.append(cellCode);
 577     }
 578
 579     if (cellcodes.length()>0)
 580     {
 581         DCCommand *command = new DCRemoveCellCodeClassCommand(getRequester(), getController(), getContainer(), cellcodes);
 582         d_undoStack.push(command);
 583
 584         if (command->getCommandResult() != DCCommand::DCCOMMAND_SUCCEEDED)
 585             r = false;
 586     }
 587
 588     QList<DCCell*> cells;
 589     for (int i = 0; i < vcells->length(); i++)
 590     {
 591         DCCell *cell = vcells->at(i)->getOwnerCell();
 592         if (cell)
 593             cells.append(cell);
 594     }
 595
 596     if (cells.length()>0)
 597     {
 598         DCCommand *command = new DCRemoveCellCommand(getRequester(), getController(), getContainer(), cells);
 599         d_undoStack.push(command);
 600
 601         if (command->getCommandResult() != DCCommand::DCCOMMAND_SUCCEEDED)
 602             r = false;
 603     }
 604
 605     QString filePath = QString::fromStdString(getContainer()->getContainerRootPath());
 606     filePath.append(d_page->getLocationPath());
 607
 608     QString sceneSettingFilePath = getScene()->getSceneSettingFilePathForPage(d_page);
 609
 610     QDir dir;
 611     if (!dir.remove(filePath))
 612     {
 613         r = false;
 614     }
 615     dir.remove(sceneSettingFilePath);
 616
 617     if (!getScene()->removePage(d_page))
 618     {
 619         r = false;
 620     }
 621
 622     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 623 }
 624
 625 void DCRemovePageCommand::undo()
 626 {
 627
 628 }
 629
 630 /*--------------------------------*/
 631 DCAddDirectoryCommand::DCAddDirectoryCommand(const void *requester, DCCreator *creator, const QString &sysFilePath)
 632     : DCCommand(requester, creator), d_path(sysFilePath)
 633 {
 634
 635 }
 636
 637 void DCAddDirectoryCommand::redo()
 638 {
 639     bool r = DCTreeViewWidget::addDirectory(d_path);
 640     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 641 }
 642
 643 void DCAddDirectoryCommand::undo()
 644 {
 645
 646 }
 647
 648 /*--------------------------------*/
 649 DCRenameDirectoryCommand::DCRenameDirectoryCommand(const void *requester, DCCreator *creator, const QString &sysOldFilePath, const QString &sysNewFilePath)
 650     : DCCommand(requester, creator), d_oldPath(sysOldFilePath), d_newPath(sysNewFilePath)
 651 {
 652
 653 }
 654
 655 void DCRenameDirectoryCommand::redo()
 656 {
 657     DCTreeViewWidget::selectWhenFilePathAdded(d_newPath);
 658     bool r = moveComponentsToDirectory(d_oldPath, d_newPath);
 659     if (r)
 660     {
 661         DCTreeViewWidget::removeDirectory(d_oldPath);
 662     }
 663     else
 664     {
 665         //TODO show error message?
 666         DCTreeViewWidget::selectWhenFilePathAdded("");
 667     }
 668     getController()->saveAll(false);
 669 }
 670
 671 void DCRenameDirectoryCommand::undo()
 672 {
 673
 674 }
 675
 676 bool DCRenameDirectoryCommand::moveComponentsToDirectory(const QString &orgSysDirectory, const QString &destSysDirectory)
 677 {
 678     if (QDir(destSysDirectory).exists())
 679         return false;
 680
 681     QDir dir;
 682     if (!dir.mkpath(destSysDirectory))
 683         return false;
 684
 685     bool r = true;
 686     QDir orgDir(orgSysDirectory);
 687     QFileInfoList list = orgDir.entryInfoList(QDir::NoDot | QDir::NoDotDot | QDir::AllEntries);
 688     for (int i = 0; r && i < list.size(); i++)
 689     {
 690         QFileInfo fileInfo = list.at(i);
 691         if (fileInfo.isDir())
 692         {
 693             QDir d(fileInfo.absoluteFilePath());
 694             QString newDir = destSysDirectory + "/" + d.dirName();
 695             r = moveComponentsToDirectory(fileInfo.absoluteFilePath(), newDir);
 696         }
 697         else
 698         {
 699             QString newFile = destSysDirectory + "/" + fileInfo.fileName();
 700             QDir newFileDir(newFile);
 701             if (!newFileDir.exists())
 702             {
 703                 QString oldFileContainerBasedPath = getContainer()->sysFilePathToContainerBasedPath(fileInfo.absoluteFilePath());
 704                 QString newFileContainerBasedPath = getContainer()->sysFilePathToContainerBasedPath(newFile);
 705                 if (getScene()->getIsPageExist(oldFileContainerBasedPath))
 706                 {
 707                     r = getContainer()->movePage(oldFileContainerBasedPath, newFileContainerBasedPath) != NULL;
 708                 }
 709                 else
 710                 {
 711                     QFile oldFile(fileInfo.absoluteFilePath());
 712                     if (oldFile.exists())
 713                     {
 714                         r = oldFile.copy(newFile);
 715                         if (r)
 716                         {
 717                             oldFile.remove();
 718                         }
 719                     }
 720                 }
 721             }
 722         }
 723     }
 724     return r;
 725 }
 726
 727
 728 /*--------------------------------*/
 729 DCRemoveDirectoryCommand::DCRemoveDirectoryCommand(const void *requester, DCCreator *creator, const QString &sysFilePath)
 730     : DCCommand(requester, creator), d_path(sysFilePath)
 731 {
 732
 733 }
 734
 735 void DCRemoveDirectoryCommand::redo()
 736 {
 737     bool r = DCTreeViewWidget::removeDirectory(d_path);
 738     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 739 }
 740
 741 void DCRemoveDirectoryCommand::undo()
 742 {
 743
 744 }
 745
 746 /*--------------------------------*/
 747 DCRenameReceptorNameCommand::DCRenameReceptorNameCommand(const void *requester, DCCreator *creator, DCCell *cell, const QString &oldName, const QString &newName)
 748     : DCCommand(requester, creator), d_cell(cell), d_oldName(oldName), d_newName(newName)
 749 {
 750
 751 }
 752
 753 void DCRenameReceptorNameCommand::redo()
 754 {
 755     bool r = d_cell->renameReceptor(d_oldName, d_newName);
 756     setCommandResult(r ? DCCommand::DCCOMMAND_SUCCEEDED : DCCommand::DCCOMMAND_FAILED);
 757 }
 758
 759 void DCRenameReceptorNameCommand::undo()
 760 {
 761
 762 }