vym: treeitem.cpp@8acac4fade1b

     1 #include <iostream>

     2 #include <QStringList>

     4 #include "treeitem.h"

     6 #include "branchobj.h"

     7 #include "branchitem.h"

     8 #include "vymmodel.h"

    10 using namespace std;

    12 extern FlagRow* standardFlagsMaster;

    14 TreeItem::TreeItem()

    15 {

    16 	//cout << "Constr. TI\n";

    17 	init();

    18 	itemData.clear();

    19 	rootItem=this;

    20 	parentItem=NULL;

    21 }

    23 TreeItem::TreeItem(const QList<QVariant> &data, TreeItem *parent)

    24 {

    25 	//cout << "Constructor TreeItem this="<<this<<"  parent="<<parent<<endl;

    26 	init();

    27     parentItem = parent;

    28     itemData = data;

    30 	rootItem=this;

    31 	if (parentItem )

    32 		rootItem=parentItem->rootItem;

    33 }

    35 TreeItem::~TreeItem()

    36 {

    37 	//cout << "Destructor TreeItem "<<getHeadingStd()<<endl;

    38 	TreeItem *ti;

    39 	while (!childItems.isEmpty())

    40 	{

    41 		ti=childItems.takeFirst();

    42 		switch (ti->getType() )

    43 		{

    44 			case TreeItem::MapCenter:

    45 				delete (BranchItem*)ti;

    46 				break;

    47 			case TreeItem::Branch:

    48 				delete (BranchItem*)ti;

    49 				break;

    50 			default:

    51 				delete ti;

    52 				break;

    53 		}

    54 	}

    55 }

    58 void TreeItem::init()

    59 {

    60 	model=NULL;

    62     parentItem = NULL;

    63     itemData.clear();

    64 	QList<QVariant> cData;

    65 	itemData<< "VM:addMapCenter" << "undef"<<"undef";

    68 	branchOffset=0;

    69 	branchCounter=0;

    70 	lastSelectedBranchNum=-1;

    72 	imageOffset=0;

    73 	imageCounter=0;

    75 	note.setNote("");

    76 	// note.setFontHint (textEditor->getFontHintDefault() );	//FIXME-2

    77 	// isNoteInEditor=false;

    79 	hidden=false;

    80 	hideExport=false;

    82 	// Reset ID

    83 	objID="";

    85 	standardFlags.setMasterRow (standardFlagsMaster);

    86 }

    89 /*

    90 void TreeItem::copy (OrnamentedObj* other)	//FIXME-2	probably need deep copy of branches and data!

    92 {

    93 	note.copy (other->note);

    94 	model=other->model;

    95 	hideExport=officially

    96 	other->hideExport;

    97 }

    98 */

   100 void TreeItem::setModel (VymModel *m)

   101 {

   102 	model=m;

   103 }

   105 VymModel* TreeItem::getModel ()

   106 {

   107 	return model;

   108 }

   110 int TreeItem::getRowNumAppend (TreeItem *item)

   111 {

   112 	switch (item->type)

   113 	{

   114 		case MapCenter: return branchOffset + branchCounter;

   115 		case Branch: return branchOffset + branchCounter;

   116 		case Image: return imageOffset + imageCounter;

   117 		default: return -1;

   118 	}

   119 }

   121 void TreeItem::appendChild(TreeItem *item)

   122 {

   123 	item->parentItem=this;

   124 	item->rootItem=rootItem;

   125 	item->setModel (model);

   127 	// If lmo exists, also set parObj there

   128 	if (lmo && item->lmo)

   129 		item->lmo->setParObj (lmo);

   131 	if (item->type == Image)

   132 	{

   133 		childItems.insert (imageCounter,item);

   134 		// images are on top of list

   135 		if (imageCounter==0)

   136 			imageOffset=0;

   137 		imageCounter++;

   138 		branchOffset++;

   139 	}

   141 	if (item->isBranchLikeType())

   142 	{

   143 		// branches are on bottom of list

   144 		childItems.append(item);

   145 		if (branchCounter==0)

   146 			branchOffset=childItems.count()-1;

   147 		branchCounter++;

   148 	}

   149 }

   151 void TreeItem::removeChild(int row)

   152 {

   153     if (row<0 || row > childItems.size()-1)

   154 		qWarning ("TreeItem::removeChild tried to remove non existing item?!\n");

   155 	else

   156 	{

   157 		if (childItems.at(row)->isBranchLikeType())

   158 			branchCounter--;

   159 		if (childItems.at(row)->type==Image)

   160 		{

   161 			imageCounter--;

   162 			if (branchOffset>0)

   163 				branchOffset--;

   164 		}

   165 		childItems.removeAt (row);

   166 	}

   167 }

   169 void TreeItem::removeChildBranches()

   170 {

   171 	while ( childItems.size()>0)

   172 	{

   173 		branchCounter--;

   174 		childItems.removeAt (0);

   175 	}

   176 }

   178 TreeItem *TreeItem::child(int row)

   179 {

   180     return childItems.value(row);

   181 }

   183 int TreeItem::childCount() const

   184 {

   185     return childItems.count();

   186 }

   188 int TreeItem::childNumber() const

   189 {

   190     if (parentItem)

   191         return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));

   193     return 0;

   194 }

   196 int TreeItem::columnCount() const

   197 {

   198     return itemData.count();

   199 }

   201 int TreeItem::branchCount() const

   202 {

   203     return branchCounter;

   204 }

   206 int TreeItem::imageCount() const

   207 {

   208     return imageCounter;

   209 }

   211 int TreeItem::xlinkCount() const // FIXME-2 check if xlinks are stored in a different way (global to model?)

   212 {

   213 	int xlinkCounter=0;

   214     return xlinkCounter; // FIXME-1 xlinkCounter needs to be calculated...

   215 }

   217 int TreeItem::row() const

   218 {

   219     if (parentItem)

   220         return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));

   222     return 0;

   223 }

   225 int TreeItem::column() const

   226 {

   227     return 0;

   228 }

   230 int TreeItem::depth()

   231 {

   232 	int d=-2;

   233 	TreeItem *ti=this;

   234 	while (ti!=NULL)

   235 	{

   236 		ti=ti->parent();

   237 		d++;

   238 	}

   239 	return d;

   240 }

   242 TreeItem *TreeItem::parent()

   243 {

   244     return parentItem;

   245 }

   247 int TreeItem::childNum()

   248 {

   249 	return parentItem->childItems.indexOf (this);

   250 }

   252 int TreeItem::num()

   253 {

   254 	switch (type)

   255 	{

   256 		case MapCenter: return parentItem->childItems.indexOf (this) - parentItem->branchOffset;

   257 		case Branch: return parentItem->childItems.indexOf (this) - parentItem->branchOffset;

   258 		case Image: return parentItem->childItems.indexOf (this) - parentItem->imageOffset;

   259 		default: return -1;

   260 	}

   261 }

   263 int TreeItem::num (TreeItem *item)

   264 {

   265 	if (!item) return -1;

   266 	if (!childItems.contains(item)) return -1;

   267 	switch (item->getType())

   268 	{

   269 		case MapCenter: return childItems.indexOf (item) - branchOffset;

   270 		case Branch: return childItems.indexOf (item) - branchOffset;

   271 		case Image: return parentItem->childItems.indexOf (item) - imageOffset;

   272 		default: return -1;

   273 	}

   274 }

   275 void TreeItem::setType(const Type t)

   276 {

   277 	type=t;

   278 	itemData[1]=getTypeName();

   279 }

   281 TreeItem::Type TreeItem::getType()

   282 {

   283 	return type;

   284 }

   286 bool TreeItem::isBranchLikeType() const

   287 {

   288 	if (type==Branch ||type==MapCenter) return true;

   289 	return false;

   290 }

   292 QString TreeItem::getTypeName()

   293 {

   294 	switch (type)

   295 	{

   296 		case Undefined: return QString ("Undefined");

   297 		case MapCenter: return QString ("MapCenter");

   298 		case Branch: return QString ("Branch");

   299 		case Image: return QString ("Image");

   300 		default: return QString ("TreeItem::getTypeName no typename defined?!");

   301 	}

   302 }

   305 QVariant TreeItem::data(int column) const

   306 {

   307     return itemData.value(column);

   308 }

   310 void TreeItem::setHeading (const QString s)

   311 {

   312 	itemData[0]=s;

   313 }

   315 QString TreeItem::getHeading () const

   316 {

   317 	return itemData[0].toString();

   318 }

   320 std::string TreeItem::getHeadingStd () const

   321 {

   322 	return itemData[0].toString().toStdString();

   323 }

   325 void TreeItem::setHeadingColor (QColor color)

   326 {

   327 	headingColor=color;

   328 }

   330 QColor TreeItem::getHeadingColor ()

   331 {

   332 	return headingColor;

   333 }

   335 void TreeItem::setURL (const QString &u)

   336 {

   337 	url=u;

   338 	if (!url.isEmpty())

   339 		systemFlags.activate ("system-url");

   340 	else

   341 		systemFlags.deactivate ("system-url");

   342 }

   344 QString TreeItem::getURL ()

   345 {

   346 	return url;

   347 }

   349 void TreeItem::setVymLink (const QString &vl)

   350 {

   351 	if (!vl.isEmpty())

   352 	{

   353 		// We need the relative (from loading)

   354 		// or absolute path (from User event)

   355 		// and build the absolute path.

   356 		// Note: If we have relative, use path of

   357 		// current map to build absolute path

   358 		QDir d(vl);

   359 		if (!d.path().startsWith ("/"))

   360 		{

   361 			QString p=model->getDestPath();

   362 			int i=p.findRev("/",-1);

   363 			d.setPath(p.left(i)+"/"+vl);

   364 			d.convertToAbs();

   365 		}

   366 		vymLink=d.path();

   367 		systemFlags.activate("system-vymLink");

   368 	}

   369 	else

   370 	{

   371 		systemFlags.deactivate("system-vymLink");

   372 		vymLink.clear();

   373 	}

   374 }

   376 QString TreeItem::getVymLink ()

   377 {

   378 	return vymLink;

   379 }

   381 void TreeItem::setNote(const QString &s)

   382 {

   383 	NoteObj n;

   384 	n.setNote(s);

   385 	setNoteObj (n,false);

   386 }

   388 void TreeItem::clearNote()

   389 {

   390 	note.clear();

   391 	systemFlags.deactivate ("system-note");

   392 }

   394 void TreeItem::setNoteObj(const NoteObj &n, bool updateNoteEditor){

   395 	note=n;

   396 	if (!note.isEmpty() && !systemFlags.isActive ("system-note"))

   397 		systemFlags.activate ("system-note");

   398 	if (note.isEmpty() && systemFlags.isActive ("system-note"))

   399 		systemFlags.deactivate ("system-note");

   400 }

   402 QString TreeItem::getNote()

   403 {

   404 	return note.getNote();

   405 }

   407 bool TreeItem::hasEmptyNote()

   408 {

   409 	return note.isEmpty();

   410 }

   412 NoteObj TreeItem::getNoteObj()

   413 {

   414 	return note;

   415 }

   417 QString TreeItem::getNoteASCII(const QString &indent, const int &width)

   418 {

   419     return note.getNoteASCII(indent,width);

   420 }

   422 QString TreeItem::getNoteASCII()

   423 {

   424     return note.getNoteASCII();

   425 }

   427 QString TreeItem::getNoteOpenDoc()

   428 {

   429     return note.getNoteOpenDoc();

   430 }

   432 void TreeItem::activateStandardFlag (const QString &name)

   433 {

   434 	standardFlags.activate (name);

   435 	model->emitDataHasChanged(this);

   436 }

   438 void TreeItem::deactivateStandardFlag (const QString &name)

   439 {

   440 	standardFlags.deactivate (name);

   441 	model->emitDataHasChanged(this);

   442 }

   444 void TreeItem::deactivateAllStandardFlags ()

   445 {

   446 	standardFlags.deactivateAll ();

   447 	model->emitDataHasChanged(this);

   448 }

   450 void TreeItem::toggleStandardFlag(const QString &name, FlagRow *master)

   451 {

   452 	standardFlags.toggle (name,master);

   453 	model->emitDataHasChanged(this);

   454 }

   456 bool TreeItem::isActiveStandardFlag (const QString &name)

   457 {

   458 	return standardFlags.isActive (name);

   459 }

   461 QStringList TreeItem::activeStandardFlagNames ()

   462 {

   463 	return standardFlags.activeFlagNames();

   464 }

   466 FlagRow* TreeItem::getStandardFlagRow()

   467 {

   468 	return &standardFlags;

   469 }

   471 /* FIXME-3 void TreeItem::updateToolBar()

   472 {

   473 	standardFlags.updateToolBar();

   474 }

   475 */

   476 QStringList TreeItem::activeSystemFlagNames ()

   477 {

   478 	return systemFlags.activeFlagNames();

   479 }

   481 bool TreeItem::canMoveDown()

   482 {

   483 	switch (type)

   484 	{

   485 		case Undefined: return false;

   486 		case MapCenter:

   487 		case Branch:

   488 			if (!parentItem) return false;

   489 			if (parentItem->num (this) < parentItem->branchCount()-1)

   490 				return true;

   491 			else

   492 				return false;

   493 			break;

   494 		case Image: return false;

   495 		default: return false;

   496 	}

   497 }

   499 bool TreeItem::canMoveUp()

   500 {

   501 	switch (type)

   502 	{

   503 		case Undefined: return false;

   504 		case MapCenter:

   505 		case Branch:

   506 			if (!parentItem) return false;

   507 			if (parentItem->num (this) > 0)

   508 				return true;

   509 			else

   510 				return false;

   511 			break;

   512 		case Image: return false;

   513 		default: return false;

   514 	}

   515 }

   517 void TreeItem::setID (const QString &s)

   518 {

   519 	objID=s;

   520 }

   522 QString TreeItem::getID()

   523 {

   524 	return objID;

   525 }

   528 TreeItem* TreeItem::getChildNum(const int &n)

   529 {

   530 	if (n>=0 && n<childItems.count() )

   531 		return childItems.at(n);

   532 	else

   533 		return NULL;

   534 }

   536 BranchItem* TreeItem::getFirstBranch()

   537 {

   538 	if (branchCounter>0)

   539 		return getBranchNum (branchOffset);

   540 	else

   541 		return NULL;

   542 }

   544 BranchItem* TreeItem::getLastBranch()

   545 {

   546 	if (branchCounter>0)

   547 		return getBranchNum (branchOffset + branchCounter-1);

   548 	else

   549 		return NULL;

   550 }

   552 BranchItem* TreeItem::getNextBranch(BranchItem *currentBranch)

   553 {

   554 	if (!currentBranch) return NULL;

   555 	int n=num (currentBranch)+1;

   556 	if (n<branchCounter)

   557 		return getBranchNum (branchOffset + n);

   558 	else

   559 		return NULL;

   560 }

   563 BranchItem* TreeItem::getBranchNum(const int &n)

   564 {

   565 	if (n>=0 && n<branchCounter)

   566 		return (BranchItem*)getChildNum (branchOffset + n);

   567 	else

   568 		return NULL;

   569 }

   571 BranchObj* TreeItem::getBranchObjNum(const int &n)

   572 {

   573 	if (n>=0 && n<branchCounter)

   574 	{

   575 		return (BranchObj*)(getBranchNum(n)->getLMO());

   576 	} else

   577 		return NULL;

   578 }

   580 void TreeItem::setLastSelectedBranch()

   581 {

   582 	if (parentItem)

   583 		parentItem->lastSelectedBranchNum=parentItem->childItems.indexOf(this);

   584 }

   586 void TreeItem::setLastSelectedBranch(int i)

   587 {

   588 		lastSelectedBranchNum=i;

   589 }

   591 TreeItem* TreeItem::getLastSelectedBranch()

   592 {

   593 	return getBranchNum (lastSelectedBranchNum);

   594 }

   596 ImageItem* TreeItem::getImageNum (const int &n)

   597 {

   598 	if (n>=0 && n<imageCounter)

   599 		return (ImageItem*)getChildNum (imageOffset + n);

   600 	else

   601 		return NULL;

   602 }

   604 FloatImageObj* TreeItem::getImageObjNum (const int &n)	// FIXME-5 what about SVGs later?

   605 {

   606 	if (imageCounter>0 )

   607 		return (FloatImageObj*)(getImageNum(n)->getLMO());

   608 	else

   609 		return NULL;

   610 }

   612 void TreeItem::setHideTmp (HideTmpMode mode)

   613 {

   614 	if (isBranchLikeType() )

   615 		((BranchItem*)this)->updateVisibility();

   616 		/*

   617 	if (type==Image)

   618 		//updateVisibility();

   619 	*/

   621 /*

   623 		if (mode==HideExport && (hideExport || hasHiddenExportParent() ) )

   624 		{

   625 			// Hide stuff according to hideExport flag and parents

   626 			//setVisibility (false);

   627 			updateVisibility();

   628 			//FIXME-2 hidden=true;

   629 		}else

   630 		{

   631 			// Do not hide, but still take care of scrolled status

   634 			XXXXXXXX treeItem should be THIS

   636 			move visible to TreeItem???

   638 			BranchObj now has updateContents

   640 			maybe also start "bool TreeItem::branchlikeType"

   644 			if ( ((BranchItem*)treeItem)->hasScrolledParent((BranchItem*)treeItem))

   645 				setVisibility (false);

   646 			else

   647 				setVisibility (true);

   648 			//FIXME-2 hidden=false;

   649 		}

   651 */

   652 		// And take care of my children

   653 		for (int i=0; i<branchCount(); ++i)

   654 			getBranchNum(i)->setHideTmp (mode);

   655 }

   657 bool TreeItem::hasHiddenExportParent()

   658 {

   659 	// Calls parents recursivly to

   660 	// find out, if we or parents are temp. hidden

   662 	if (hidden || hideExport) return true;

   664 	if (parentItem)

   665 		return parentItem->hasHiddenExportParent();

   666 	else

   667 		return false;

   668 }

   671 void TreeItem::setHideInExport(bool b)

   672 {

   673 	if (type==Branch || type==Image)

   674 	{

   675 		hideExport=b;

   676 		if (b)

   677 			systemFlags.activate("system-hideInExport");

   678 		else

   679 			systemFlags.deactivate("system-hideInExport");

   680 	}

   681 }

   683 bool TreeItem::hideInExport()

   684 {

   685 	return hideExport;

   686 }

   688 bool TreeItem::isHidden()

   689 {

   690 	return hidden;

   691 }

   693 QString TreeItem::getAttr()

   694 {

   695 	QString s;

   696 	if (parentItem==rootItem)

   697 		posMode=Absolute;

   698 	else

   699 	{

   700 		if (type==TreeItem::Image ||depth()==1)

   701 			posMode=Relative;

   702 		else

   703 			posMode=Unused;

   704 	}

   705 	switch (posMode)

   706 	{

   707 		case Relative:

   708 			if (lmo) pos=lmo->getRelPos();

   709 			s= attribut("relPosX",QString().setNum(pos.x())) +

   710 			   attribut("relPosY",QString().setNum(pos.y()));

   711 			break;

   712 		case Absolute:

   713 			if (lmo) pos=lmo->getAbsPos();

   714 			s=attribut("absPosX",QString().setNum(pos.x())) +

   715 			  attribut("absPosY",QString().setNum(pos.y()));

   716 			break;

   717 		default: break;

   718 	}

   719 	if (hideExport)

   720 		return s+attribut("hideInExport","true");

   721 	else

   722 		return s;

   723 }

author	insilmaril
	Mon, 29 Jun 2009 10:27:42 +0000
changeset 777	8acac4fade1b
parent 776	25e634a7e1dc
child 779	1fb50e79661c
permissions	-rw-r--r--