src/vymmodelwrapper.cpp

   1 #include "vymmodelwrapper.h"
   2
   3 #include "branchitem.h"
   4 #include "branchobj.h"
   5 #include "imageitem.h"
   6 #include "misc.h"
   7 #include "scripting.h"
   8 #include "vymmodel.h"
   9 #include "vymtext.h"
  10 #include "xlink.h"
  11 #include "xmlobj.h" // include quoteQuotes
  12
  13 ///////////////////////////////////////////////////////////////////////////
  14 VymModelWrapper::VymModelWrapper(VymModel *m) { model = m; }
  15
  16 /*
  17 QString VymModelWrapper::setResult( const QString r )
  18 {
  19     context()->engine()->globalObject().setProperty("lastResult", r );
  20 }
  21
  22 bool VymModelWrapper::setResult( bool r )
  23 {
  24     context()->engine()->globalObject().setProperty("lastResult", r );
  25 }
  26
  27 int  VymModelWrapper::setResult( int r )
  28 {
  29     context()->engine()->globalObject().setProperty("lastResult", r );
  30 }
  31 */
  32
  33 BranchItem *VymModelWrapper::getSelectedBranch()
  34 {
  35     BranchItem *selbi = model->getSelectedBranch();
  36     if (!selbi)
  37         logError(context(), QScriptContext::ReferenceError,
  38                  "No branch selected");
  39     return selbi;
  40 }
  41
  42 QVariant VymModelWrapper::getParameter(bool &ok, const QString &key,
  43                                        const QStringList &parameters)
  44 {
  45     // loop through parameters and try to find the one named "key"
  46     foreach (QString par, parameters) {
  47         if (par.startsWith(key)) {
  48             qDebug() << "getParam: " << key << "  has: " << par;
  49             ok = true;
  50             return QVariant(par);
  51         }
  52     }
  53
  54     // Nothing found
  55     ok = false;
  56     return QVariant::Invalid;
  57 }
  58
  59 void VymModelWrapper::addBranch()
  60 {
  61     BranchItem *selbi = getSelectedBranch();
  62     if (selbi) {
  63         if (argumentCount() > 1) {
  64             logError(context(), QScriptContext::SyntaxError,
  65                      "Too many arguments");
  66             return;
  67         }
  68
  69         int pos = -2;
  70         if (argumentCount() == 1) {
  71             pos = argument(0).toInteger();
  72         }
  73
  74         if (!model->addNewBranch(selbi, pos))
  75             logError(context(), QScriptContext::UnknownError,
  76                      "Couldn't add branch to map");
  77     }
  78 }
  79
  80 void VymModelWrapper::addBranchBefore()
  81 {
  82     if (!model->addNewBranchBefore())
  83         logError(context(), QScriptContext::UnknownError,
  84                  "Couldn't add branch before selection to map");
  85 }
  86
  87 void VymModelWrapper::addMapCenter(qreal x, qreal y)
  88 {
  89     if (!model->addMapCenter(QPointF(x, y)))
  90         logError(context(), QScriptContext::UnknownError,
  91                  "Couldn't add mapcenter");
  92 }
  93
  94 void VymModelWrapper::addMapInsert(QString fileName, int pos, int contentFilter)
  95 {
  96     if (QDir::isRelativePath(fileName))
  97         fileName = QDir::currentPath() + "/" + fileName;
  98
  99     model->saveStateBeforeLoad(ImportAdd, fileName);
 100
 101     if (File::Aborted ==
 102         model->loadMap(fileName, ImportAdd, VymMap, contentFilter, pos))
 103         logError(context(), QScriptContext::UnknownError,
 104                  QString("Couldn't load %1").arg(fileName));
 105 }
 106
 107 void VymModelWrapper::addMapInsert(const QString &fileName, int pos)
 108 {
 109     addMapInsert(fileName, pos, 0x0000);
 110 }
 111
 112 void VymModelWrapper::addMapInsert(const QString &fileName)
 113 {
 114     addMapInsert(fileName, -1, 0x0000);
 115 }
 116
 117 void VymModelWrapper::addMapReplace(QString fileName)
 118 {
 119     if (QDir::isRelativePath(fileName))
 120         fileName = QDir::currentPath() + "/" + fileName;
 121
 122     model->saveStateBeforeLoad(ImportReplace, fileName);
 123
 124     if (File::Aborted == model->loadMap(fileName, ImportReplace, VymMap))
 125         logError(context(), QScriptContext::UnknownError,
 126                  QString("Couldn't load %1").arg(fileName));
 127 }
 128
 129 void VymModelWrapper::addSlide() { model->addSlide(); }
 130
 131 void VymModelWrapper::addXLink(const QString &begin, const QString &end,
 132                                int width, const QString &color,
 133                                const QString &penstyle)
 134 {
 135     BranchItem *bbegin = (BranchItem *)(model->findBySelectString(begin));
 136     BranchItem *bend = (BranchItem *)(model->findBySelectString(end));
 137     if (bbegin && bend) {
 138         if (bbegin->isBranchLikeType() && bend->isBranchLikeType()) {
 139             Link *li = new Link(model);
 140             li->setBeginBranch((BranchItem *)bbegin);
 141             li->setEndBranch((BranchItem *)bend);
 142
 143             model->createLink(li);
 144             QPen pen = li->getPen();
 145             if (width > 0)
 146                 pen.setWidth(width);
 147             QColor col(color);
 148             if (col.isValid())
 149                 pen.setColor(col);
 150             else {
 151                 logError(context(), QScriptContext::UnknownError,
 152                          QString("Could not set color to %1").arg(color));
 153                 return;
 154             }
 155
 156             bool ok;
 157             Qt::PenStyle st1 = penStyle(penstyle, ok);
 158             if (ok) {
 159                 pen.setStyle(st1);
 160                 li->setPen(pen);
 161             }
 162             else
 163                 logError(context(), QScriptContext::UnknownError,
 164                          QString("Couldn't set penstyle %1").arg(penstyle));
 165         }
 166         else
 167             logError(context(), QScriptContext::UnknownError,
 168                      "Begin or end of xLink are not branch or mapcenter");
 169     }
 170     else
 171         logError(context(), QScriptContext::UnknownError,
 172                  "Begin or end of xLink not found");
 173 }
 174
 175 int VymModelWrapper::branchCount()
 176 {
 177     int r;
 178     BranchItem *selbi = getSelectedBranch();
 179     if (selbi)
 180         r = selbi->branchCount();
 181     else
 182         r = -1;
 183     return setResult(r);
 184 }
 185
 186 int VymModelWrapper::centerCount()
 187 {
 188     int r = model->centerCount();
 189     return setResult(r);
 190 }
 191
 192 void VymModelWrapper::centerOnID(const QString &id)
 193 {
 194     if (!model->centerOnID(id))
 195         logError(context(), QScriptContext::UnknownError,
 196                  QString("Could not center on ID %1").arg(id));
 197 }
 198
 199 void VymModelWrapper::clearFlags() { model->clearFlags(); }
 200
 201 void VymModelWrapper::colorBranch(const QString &color)
 202 {
 203     QColor col(color);
 204     if (!col.isValid())
 205         logError(context(), QScriptContext::SyntaxError,
 206                  QString("Could not set color to %1").arg(color));
 207     else
 208         model->colorBranch(col);
 209 }
 210
 211 void VymModelWrapper::colorSubtree(const QString &color)
 212 {
 213     QColor col(color);
 214     if (!col.isValid())
 215         logError(context(), QScriptContext::SyntaxError,
 216                  QString("Could not set color to %1").arg(color));
 217     else
 218         model->colorSubtree(col);
 219 }
 220
 221 void VymModelWrapper::copy() { model->copy(); }
 222
 223 void VymModelWrapper::cut() { model->cut(); }
 224
 225 void VymModelWrapper::cycleTask()
 226 {
 227     if (!model->cycleTaskStatus())
 228         logError(context(), QScriptContext::SyntaxError,
 229                  "Couldn't cycle task status");
 230 }
 231
 232 int VymModelWrapper::depth()
 233 {
 234     TreeItem *selti = model->getSelectedItem();
 235     if (selti)
 236         return setResult(selti->depth());
 237     else
 238         return setResult (-2);  // FIXME-2 should throw error
 239 }
 240
 241 bool VymModelWrapper::exportMap()
 242 {
 243     bool r = false;
 244
 245     if (argumentCount() == 0) {
 246         logError(context(), QScriptContext::SyntaxError,
 247                  "Not enough arguments");
 248         return setResult(r);
 249     }
 250
 251     QString format;
 252     format = argument(0).toString();
 253
 254     if (argumentCount() == 1) {
 255         if (format == "Last") {
 256             model->exportLast();
 257             r = true;
 258         }
 259         else
 260             logError(context(), QScriptContext::SyntaxError,
 261                      "Filename missing");
 262         return setResult(r);
 263     }
 264
 265     QString filename;
 266
 267     filename = argument(1).toString();
 268
 269     if (format == "AO") {
 270         model->exportAO(filename, false);
 271     }
 272     else if (format == "ASCII") {
 273         bool listTasks = false;
 274         if (argumentCount() == 3 && argument(2).toString() == "true")
 275             listTasks = true;
 276         model->exportASCII(filename, listTasks, false);
 277     }
 278     else if (format == "ConfluenceNewPage") {
 279         // 0: General export format
 280         // 1: URL of parent page (required)
 281         // 2: page title (required)
 282         if (argumentCount() < 3) {
 283             logError(context(), QScriptContext::SyntaxError,
 284                  QString("Confluence export new page: Only %1 instead of 3 parameters given")
 285                  .arg(argumentCount()));
 286             return setResult(r);
 287         }
 288
 289         QString url = argument(2).toString();
 290         QString pageName = argument(3).toString();
 291
 292         model->exportConfluence(true, url, pageName, false);
 293     }
 294     else if (format == "ConfluenceUpdatePage") {
 295         // 0: General export format
 296         // 1: URL of  page to be updated
 297         // 2: page title (optional)
 298         if (argumentCount() == 1) {
 299             logError(context(), QScriptContext::SyntaxError,
 300                      "URL of new page missing in Confluence export");
 301             return setResult(r);
 302         }
 303         QString url = argument(1).toString();
 304
 305         QString title = "";
 306         if (argumentCount() == 3) {
 307             title = argument(2).toString();
 308         }
 309
 310         model->exportConfluence(false, url, title, false);
 311     }
 312     else if (format == "CSV") {
 313         model->exportCSV(filename, false);
 314     }
 315     else if (format == "HTML") {
 316         if (argumentCount() < 3) {
 317             logError(context(), QScriptContext::SyntaxError,
 318                      "Path missing in HTML export");
 319             return setResult(r);
 320         }
 321         QString dpath = argument(2).toString();
 322         model->exportHTML(filename, dpath, false);
 323     }
 324     else if (format == "Image") {
 325         QString imgFormat;
 326         if (argumentCount() == 2)
 327             imgFormat = "PNG";
 328         else if (argumentCount() == 3)
 329             imgFormat = argument(2).toString();
 330
 331         QStringList formats;
 332         formats << "PNG";
 333         formats << "GIF";
 334         formats << "JPG";
 335         formats << "JPEG", formats << "PNG", formats << "PBM", formats << "PGM",
 336             formats << "PPM", formats << "TIFF", formats << "XBM",
 337             formats << "XPM";
 338         if (formats.indexOf(imgFormat) < 0) {
 339             logError(context(), QScriptContext::SyntaxError,
 340                      QString("%1 not one of the known export formats: ")
 341                          .arg(imgFormat)
 342                          .arg(formats.join(",")));
 343             return setResult(r);
 344         }
 345         model->exportImage(filename, false, imgFormat);
 346     }
 347     else if (format == "Impress") {
 348         if (argumentCount() < 3) {
 349             logError(context(), QScriptContext::SyntaxError,
 350                      "Template file  missing in export to Impress");
 351             return setResult(r);
 352         }
 353         QString templ = argument(2).toString();
 354         model->exportImpress(filename, templ);
 355     }
 356     else if (format == "LaTeX") {
 357         model->exportLaTeX(filename, false);
 358     }
 359     else if (format == "Markdown") {
 360         model->exportMarkdown(filename, false);
 361     }
 362     else if (format == "OrgMode") {
 363         model->exportOrgMode(filename, false);
 364     }
 365     else if (format == "PDF") {
 366         model->exportPDF(filename, false);
 367     }
 368     else if (format == "SVG") {
 369         model->exportSVG(filename, false);
 370     }
 371     else if (format == "XML") {
 372         if (argumentCount() < 3) {
 373             logError(context(), QScriptContext::SyntaxError,
 374                      "path missing in export to Impress");
 375             return setResult(r);
 376         }
 377         QString dpath = argument(2).toString();
 378         model->exportXML(filename, dpath, false);
 379     }
 380     else {
 381         logError(context(), QScriptContext::SyntaxError,
 382                  QString("Unknown export format: %1").arg(format));
 383         return setResult(r);
 384     }
 385     return setResult(true);
 386 }
 387
 388 int VymModelWrapper::getBranchIndex()
 389 {
 390     int r;
 391     BranchItem *selbi = getSelectedBranch();
 392     if (selbi) {
 393         r = selbi->num();
 394     } else
 395         r = -1;
 396     return setResult(r);
 397 }
 398
 399 QString VymModelWrapper::getDestPath()
 400 {
 401     QString r = model->getDestPath();
 402     return setResult(r);
 403 }
 404
 405 QString VymModelWrapper::getFileDir() { return setResult(model->getFileDir()); }
 406
 407 QString VymModelWrapper::getFileName()
 408 {
 409     return setResult(model->getFileName());
 410 }
 411
 412 QString VymModelWrapper::getFrameType()
 413 {
 414     QString r;
 415     BranchItem *selbi = getSelectedBranch();
 416     if (selbi) {
 417         BranchObj *bo = (BranchObj *)(selbi->getLMO());
 418         if (!bo)
 419             logError(context(), QScriptContext::UnknownError,
 420                      QString("No BranchObj available"));
 421         else
 422             r = bo->getFrame()->getFrameTypeName();
 423     }
 424     return setResult(r);
 425 }
 426
 427 QString VymModelWrapper::getHeadingPlainText()
 428 {
 429     QString r = model->getHeading().getTextASCII();
 430     return setResult(r);
 431 }
 432
 433 QString VymModelWrapper::getHeadingXML()
 434 {
 435     QString r = model->getHeading().saveToDir();
 436     return setResult(r);
 437 }
 438
 439 QString VymModelWrapper::getMapAuthor()
 440 {
 441     return setResult(model->getAuthor());
 442 }
 443
 444 QString VymModelWrapper::getMapComment()
 445 {
 446     return setResult(model->getComment());
 447 }
 448
 449 QString VymModelWrapper::getMapTitle() { return setResult(model->getTitle()); }
 450
 451 QString VymModelWrapper::getNotePlainText()
 452 {
 453     return setResult(model->getNote().getTextASCII());
 454 }
 455
 456 QString VymModelWrapper::getNoteXML()
 457 {
 458     return setResult(model->getNote().saveToDir());
 459 }
 460
 461 QString VymModelWrapper::getSelectionString()
 462 {
 463     return setResult(model->getSelectString());
 464 }
 465
 466 int VymModelWrapper::getTaskPriorityDelta()
 467 {
 468     return model->getTaskPriorityDelta();
 469 }
 470
 471 QString VymModelWrapper::getTaskSleep()
 472 {
 473     QString r;
 474     BranchItem *selbi = getSelectedBranch();
 475     if (selbi) {
 476         Task *task = selbi->getTask();
 477         if (task)
 478             r = task->getSleep().toString(Qt::ISODate);
 479         else
 480             logError(context(), QScriptContext::UnknownError,
 481                      "Branch has no task");
 482     }
 483     return setResult(r);
 484 }
 485
 486 int VymModelWrapper::getTaskSleepDays()
 487 {
 488     int r = -1;
 489     BranchItem *selbi = getSelectedBranch();
 490     if (selbi) {
 491         Task *task = selbi->getTask();
 492         if (task)
 493             r = task->getDaysSleep();
 494         else
 495             logError(context(), QScriptContext::UnknownError,
 496                      "Branch has no task");
 497     }
 498     return setResult(r);
 499 }
 500
 501 QString VymModelWrapper::getURL() { return setResult(model->getURL()); }
 502
 503 QString VymModelWrapper::getVymLink() { return setResult(model->getVymLink()); }
 504
 505 QString VymModelWrapper::getXLinkColor()
 506 {
 507     return setResult(model->getXLinkColor().name());
 508 }
 509
 510 int VymModelWrapper::getXLinkWidth()
 511 {
 512     return setResult(model->getXLinkWidth());
 513 }
 514
 515 QString VymModelWrapper::getXLinkPenStyle()
 516 {
 517     QString r = penStyleToString(model->getXLinkStyle());
 518     return setResult(r);
 519 }
 520
 521 QString VymModelWrapper::getXLinkStyleBegin()
 522 {
 523     return setResult(model->getXLinkStyleBegin());
 524 }
 525
 526 QString VymModelWrapper::getXLinkStyleEnd()
 527 {
 528     return setResult(model->getXLinkStyleEnd());
 529 }
 530
 531 bool VymModelWrapper::hasActiveFlag(const QString &flag)
 532 {
 533     bool r = false;
 534     BranchItem *selbi = getSelectedBranch();
 535     if (selbi)
 536         r = selbi->hasActiveFlag(flag);
 537     return setResult(r);
 538 }
 539
 540 bool VymModelWrapper::hasNote()
 541 {
 542     bool r = !model->getNote().isEmpty();
 543     return setResult(r);
 544 }
 545
 546 bool VymModelWrapper::hasRichTextNote()
 547 {
 548     return setResult(model->hasRichTextNote());
 549 }
 550
 551 bool VymModelWrapper::hasTask()
 552 {
 553     bool r = false;
 554     BranchItem *selbi = getSelectedBranch();
 555     if (selbi) {
 556         Task *task = selbi->getTask();
 557         if (task)
 558             r = true;
 559     }
 560     else
 561         logError(context(), QScriptContext::UnknownError,
 562                  "Selected item is not a branch");
 563
 564     return setResult(r);
 565 }
 566
 567 void VymModelWrapper::importDir(const QString &path)
 568 {
 569     model->importDir(
 570         path); // FIXME-3 error handling missing (in vymmodel and here)
 571 }
 572
 573 bool VymModelWrapper::initIterator(const QString &iname, bool deepLevelsFirst)
 574 {
 575     return model->initIterator(iname, deepLevelsFirst);
 576 }
 577
 578 bool VymModelWrapper::nextIterator(const QString &iname)
 579 {
 580     return model->nextIterator(iname);
 581 }
 582
 583 bool VymModelWrapper::isScrolled()
 584 {
 585     bool r = false;
 586     BranchItem *selbi = getSelectedBranch();
 587     if (selbi)
 588         r = selbi->isScrolled();
 589     return setResult(r);
 590 }
 591
 592 void VymModelWrapper::loadImage(const QString &filename)
 593 {
 594     BranchItem *selbi = getSelectedBranch();
 595     if (selbi) {
 596         model->loadImage(
 597             selbi,
 598             filename); // FIXME-3 error handling missing (in vymmodel and here)
 599     }
 600 }
 601
 602 void VymModelWrapper::loadNote(const QString &filename)
 603 {
 604     model->loadNote(
 605         filename); // FIXME-3 error handling missing (in vymmodel and here)
 606 }
 607
 608 void VymModelWrapper::move(qreal x, qreal y)
 609 {
 610     model->move(x, y);
 611     ;
 612 }
 613
 614 void VymModelWrapper::moveRel(qreal x, qreal y)
 615 {
 616     model->moveRel(x, y);
 617     ;
 618 }
 619
 620 void VymModelWrapper::moveDown() { model->moveDown(); }
 621
 622 void VymModelWrapper::moveUp() { model->moveUp(); }
 623
 624 void VymModelWrapper::moveSlideDown(int n)
 625 {
 626     if (!model->moveSlideDown(n))
 627         logError(context(), QScriptContext::UnknownError,
 628                  "Could not move slide down");
 629 }
 630
 631 void VymModelWrapper::moveSlideDown() { moveSlideDown(-1); }
 632
 633 void VymModelWrapper::moveSlideUp(int n)
 634 {
 635     if (!model->moveSlideUp(n))
 636         logError(context(), QScriptContext::UnknownError,
 637                  "Could not move slide up");
 638 }
 639
 640 void VymModelWrapper::moveSlideUp() { moveSlideUp(-1); }
 641
 642 void VymModelWrapper::nop() {}
 643
 644 void VymModelWrapper::note2URLs() { model->note2URLs(); }
 645
 646 bool VymModelWrapper::parseVymText(const QString &text)
 647 {
 648     return setResult(model->parseVymText(unquoteQuotes(text)));
 649 }
 650
 651 void VymModelWrapper::paste() { model->paste(); }
 652
 653 void VymModelWrapper::redo() { model->redo(); }
 654
 655 bool VymModelWrapper::relinkTo(const QString &parent, int num, qreal x, qreal y)
 656 {
 657     bool r;
 658     r = model->relinkTo(parent, num, QPointF(x, y));
 659     if (!r)
 660         logError(context(), QScriptContext::UnknownError, "Could not relink");
 661     return setResult(r);
 662 }
 663
 664 bool VymModelWrapper::relinkTo(const QString &parent, int num)
 665 {
 666     bool r = relinkTo(parent, num, 0, 0);
 667     return setResult(r);
 668 }
 669
 670 bool VymModelWrapper::relinkTo(const QString &parent)
 671 {
 672     bool r = relinkTo(parent, -1, 0, 0);
 673     return setResult(r);
 674 }
 675
 676 void VymModelWrapper::remove() { model->deleteSelection(); }
 677
 678 void VymModelWrapper::removeChildren() { model->deleteChildren(); }
 679
 680 void VymModelWrapper::removeKeepChildren() { model->deleteKeepChildren(); }
 681
 682 void VymModelWrapper::removeSlide(int n)
 683 {
 684     if (n < 0 || n >= model->slideCount() - 1)
 685         logError(context(), QScriptContext::RangeError,
 686                  QString("Slide '%1' not available.").arg(n));
 687 }
 688
 689 QVariant VymModelWrapper::repeatLastCommand()
 690 {
 691     return model->repeatLastCommand();
 692 }
 693
 694 void VymModelWrapper::saveImage(const QString &filename)
 695 {
 696     model->saveImage(NULL, filename);
 697 }
 698
 699 void VymModelWrapper::saveNote(const QString &filename)
 700 {
 701     model->saveNote(filename);
 702 }
 703
 704 void VymModelWrapper::scroll()
 705 {
 706     BranchItem *selbi = getSelectedBranch();
 707     if (selbi) {
 708         if (!model->scrollBranch(selbi))
 709             logError(context(), QScriptContext::UnknownError,
 710                      "Couldn't scroll branch");
 711     }
 712 }
 713
 714 bool VymModelWrapper::select(const QString &s)
 715 {
 716     bool r = model->select(s);
 717     if (!r)
 718         logError(context(), QScriptContext::UnknownError,
 719                  QString("Couldn't select %1").arg(s));
 720     return setResult(r);
 721 }
 722
 723 bool VymModelWrapper::selectID(const QString &s)
 724 {
 725     bool r = model->selectID(s);
 726     if (!r)
 727         logError(context(), QScriptContext::UnknownError,
 728                  QString("Couldn't select ID %1").arg(s));
 729     return setResult(r);
 730 }
 731
 732 bool VymModelWrapper::selectFirstBranch()
 733 {
 734     bool r = false;
 735     BranchItem *selbi = getSelectedBranch();
 736     if (selbi) {
 737         r = model->selectFirstBranch();
 738         if (!r)
 739             logError(context(), QScriptContext::UnknownError,
 740                      "Couldn't select first branch");
 741     }
 742     return setResult(r);
 743 }
 744
 745 bool VymModelWrapper::selectFirstChildBranch()
 746 {
 747     bool r = false;
 748     BranchItem *selbi = getSelectedBranch();
 749     if (selbi) {
 750         r = model->selectFirstChildBranch();
 751         if (!r)
 752             logError(context(), QScriptContext::UnknownError,
 753                      "Couldn't select first child branch");
 754     }
 755     return setResult(r);
 756 }
 757
 758 bool VymModelWrapper::selectLastBranch()
 759 {
 760     bool r = false;
 761     BranchItem *selbi = getSelectedBranch();
 762     if (selbi) {
 763         r = model->selectLastBranch();
 764         if (!r)
 765             logError(context(), QScriptContext::UnknownError,
 766                      "Couldn't select last branch");
 767     }
 768     return setResult(r);
 769 }
 770
 771 bool VymModelWrapper::selectLastChildBranch()
 772 {
 773     bool r = false;
 774     BranchItem *selbi = getSelectedBranch();
 775     if (selbi) {
 776         r = model->selectLastChildBranch();
 777         if (!r)
 778             logError(context(), QScriptContext::UnknownError,
 779                      "Couldn't select last child branch");
 780     }
 781     return setResult(r);
 782 }
 783 bool VymModelWrapper::selectLastImage()
 784 {
 785     bool r = false;
 786     BranchItem *selbi = getSelectedBranch();
 787     if (selbi) {
 788         ImageItem *ii = selbi->getLastImage();
 789         if (!ii)
 790             logError(context(), QScriptContext::UnknownError,
 791                      "Couldn't get last image");
 792         else {
 793             r = model->select(ii);
 794             if (!r)
 795                 logError(context(), QScriptContext::UnknownError,
 796                          "Couldn't select last image");
 797         }
 798     }
 799     return setResult(r);
 800 }
 801
 802 bool VymModelWrapper::selectParent()
 803 {
 804     bool r = model->selectParent();
 805     if (!r)
 806         logError(context(), QScriptContext::UnknownError,
 807                  "Couldn't select parent item");
 808     return setResult(r);
 809 }
 810
 811 bool VymModelWrapper::selectLatestAdded()
 812 {
 813     bool r = model->selectLatestAdded();
 814     if (!r)
 815         logError(context(), QScriptContext::UnknownError,
 816                  "Couldn't select latest added item");
 817     return setResult(r);
 818 }
 819
 820 bool VymModelWrapper::selectToggle(const QString &selectString)
 821 {
 822     bool r = model->selectToggle(selectString);
 823     if (!r)
 824         logError(context(), QScriptContext::UnknownError,
 825                  "Couldn't toggle item with select string " + selectString);
 826     return setResult(r);
 827 }
 828
 829 void VymModelWrapper::setFlagByName(const QString &s)
 830 {
 831     model->setFlagByName(s);
 832 }
 833
 834 void VymModelWrapper::setHeadingConfluencePageName()
 835 {
 836     model->setHeadingConfluencePageName();
 837 }
 838
 839 void VymModelWrapper::setHeadingPlainText(
 840     const QString &text) // FIXME-3  what about RT?
 841 {
 842     model->setHeadingPlainText(text);
 843 }
 844
 845 void VymModelWrapper::setHideExport(bool b) { model->setHideExport(b); }
 846
 847 void VymModelWrapper::setIncludeImagesHorizontally(bool b)
 848 {
 849     model->setIncludeImagesHor(b);
 850 }
 851
 852 void VymModelWrapper::setIncludeImagesVertically(bool b)
 853 {
 854     model->setIncludeImagesVer(b);
 855 }
 856
 857 void VymModelWrapper::setHideLinkUnselected(bool b)
 858 {
 859     model->setHideLinkUnselected(b);
 860 }
 861
 862 void VymModelWrapper::setMapAnimCurve(int n)
 863 {
 864     if (n < 0 || n > QEasingCurve::OutInBounce)
 865         logError(context(), QScriptContext::RangeError,
 866                  "Unknown animation curve type");
 867     else {
 868         QEasingCurve c;
 869         c.setType((QEasingCurve::Type)n);
 870         model->setMapAnimCurve(c);
 871     }
 872 }
 873
 874 void VymModelWrapper::setMapAnimDuration(int n)
 875 {
 876     model->setMapAnimDuration(n);
 877 }
 878
 879 void VymModelWrapper::setMapAuthor(const QString &s) { model->setAuthor(s); }
 880
 881 void VymModelWrapper::setMapBackgroundColor(const QString &color)
 882 {
 883     QColor col(color);
 884     if (col.isValid()) {
 885         model->setMapBackgroundColor(col);
 886     }
 887     else
 888         logError(context(), QScriptContext::UnknownError,
 889                  QString("Could not set color to %1").arg(color));
 890 }
 891
 892 void VymModelWrapper::setMapComment(const QString &s) { model->setComment(s); }
 893
 894 void VymModelWrapper::setMapDefLinkColor(const QString &color)
 895 {
 896     QColor col(color);
 897     if (col.isValid()) {
 898         model->setMapDefLinkColor(col);
 899     }
 900     else
 901         logError(context(), QScriptContext::UnknownError,
 902                  QString("Could not set color to %1").arg(color));
 903 }
 904
 905 void VymModelWrapper::setMapLinkStyle(const QString &style)
 906 {
 907     if (!model->setMapLinkStyle(style))
 908         logError(context(), QScriptContext::UnknownError,
 909                  QString("Could not set linkstyle to %1").arg(style));
 910 }
 911
 912 void VymModelWrapper::setMapRotation(float a) { model->setMapRotationAngle(a); }
 913
 914 void VymModelWrapper::setMapTitle(const QString &s) { model->setTitle(s); }
 915
 916 void VymModelWrapper::setMapZoom(float z) { model->setMapZoomFactor(z); }
 917
 918 void VymModelWrapper::setNotePlainText(const QString &s)
 919 {
 920     VymNote vn;
 921     vn.setPlainText(s);
 922     model->setNote(vn);
 923 }
 924
 925 void VymModelWrapper::setFrameBorderWidth(int width)
 926 {
 927     model->setFrameBorderWidth(width);
 928 }
 929
 930 void VymModelWrapper::setFrameBrushColor(const QString &color)
 931 {
 932     model->setFrameBrushColor(color);
 933 }
 934
 935 void VymModelWrapper::setFrameIncludeChildren(bool b)
 936 {
 937     model->setFrameIncludeChildren(b);
 938 }
 939
 940 void VymModelWrapper::setFramePadding(int padding)
 941 {
 942     model->setFramePadding(padding);
 943 }
 944
 945 void VymModelWrapper::setFramePenColor(const QString &color)
 946 {
 947     model->setFramePenColor(color);
 948 }
 949
 950 void VymModelWrapper::setFrameType(const QString &type)
 951 {
 952     model->setFrameType(type);
 953 }
 954
 955 void VymModelWrapper::setScaleFactor(qreal f) { model->setScaleFactor(f); }
 956
 957 void VymModelWrapper::setSelectionBrushColor(const QString &color)
 958 {
 959     QColor col(color);
 960     if (!col.isValid())
 961         logError(context(), QScriptContext::SyntaxError,
 962                  QString("Could not set color to %1").arg(color));
 963     else
 964         model->setSelectionBrushColor(col);
 965 }
 966
 967 void VymModelWrapper::setSelectionPenColor(const QString &color)
 968 {
 969     QColor col(color);
 970     if (!col.isValid())
 971         logError(context(), QScriptContext::SyntaxError,
 972                  QString("Could not set color to %1").arg(color));
 973     else
 974         model->setSelectionPenColor(col);
 975 }
 976
 977 void VymModelWrapper::setSelectionPenWidth(const qreal &w)
 978 {
 979     model->setSelectionPenWidth(w);
 980 }
 981
 982 void VymModelWrapper::setTaskPriorityDelta(const int &n)
 983 {
 984     model->setTaskPriorityDelta(n);
 985 }
 986
 987 bool VymModelWrapper::setTaskSleep(const QString &s)
 988 {
 989     bool r = model->setTaskSleep(s);
 990     return setResult(r);
 991 }
 992
 993 void VymModelWrapper::setURL(const QString &s) { model->setURL(s); }
 994
 995 void VymModelWrapper::setVymLink(const QString &s) { model->setVymLink(s); }
 996
 997 void VymModelWrapper::setXLinkColor(const QString &color)
 998 {
 999     QColor col(color);
1000     if (!col.isValid())
1001         logError(context(), QScriptContext::SyntaxError,
1002                  QString("Could not set color to %1").arg(color));
1003     else
1004         model->setXLinkColor(color); // FIXME-3 try to use QColor here...
1005 }
1006
1007 void VymModelWrapper::setXLinkStyle(const QString &style)
1008 {
1009     model->setXLinkStyle(style);
1010 }
1011
1012 void VymModelWrapper::setXLinkStyleBegin(const QString &style)
1013 {
1014     model->setXLinkStyleBegin(style);
1015 }
1016
1017 void VymModelWrapper::setXLinkStyleEnd(const QString &style)
1018 {
1019     model->setXLinkStyleEnd(style);
1020 }
1021
1022 void VymModelWrapper::setXLinkWidth(int w) { model->setXLinkWidth(w); }
1023
1024 void VymModelWrapper::sleep(int n)
1025 {
1026     // sleep is not avail on windows VCEE, workaround could be using
1027     // this->thread()->wait(x ms)
1028     sleep(n);
1029 }
1030
1031 void VymModelWrapper::sortChildren(bool b) { model->sortChildren(b); }
1032
1033 void VymModelWrapper::sortChildren() { sortChildren(false); }
1034
1035 void VymModelWrapper::toggleFlagByUid(const QString &s)
1036 {
1037     model->toggleFlagByUid(QUuid(s));
1038 }
1039
1040 void VymModelWrapper::toggleFlagByName(const QString &s)
1041 {
1042     model->toggleFlagByName(s);
1043 }
1044
1045 void VymModelWrapper::toggleFrameIncludeChildren()
1046 {
1047     model->toggleFrameIncludeChildren();
1048 }
1049
1050 void VymModelWrapper::toggleScroll() { model->toggleScroll(); }
1051
1052 void VymModelWrapper::toggleTarget() { model->toggleTarget(); }
1053
1054 void VymModelWrapper::toggleTask() { model->toggleTask(); }
1055
1056 void VymModelWrapper::undo() { model->undo(); }
1057
1058 bool VymModelWrapper::unscroll()
1059 {
1060     bool r = false;
1061     BranchItem *selbi = getSelectedBranch();
1062     if (selbi) {
1063         r = model->unscrollBranch(selbi);
1064         if (!r)
1065             logError(context(), QScriptContext::UnknownError,
1066                      "Couldn't unscroll branch");
1067     }
1068     return setResult(r);
1069 }
1070
1071 void VymModelWrapper::unscrollChildren() { model->unscrollChildren(); }
1072
1073 void VymModelWrapper::unselectAll() { model->unselectAll(); }
1074
1075 void VymModelWrapper::unsetFlagByName(const QString &s)
1076 {
1077     model->unsetFlagByName(s);
1078 }