Mercurialvym / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
treeitem.cpp
author insilmaril
Thu, 03 Sep 2009 08:52:00 +0000
changeset 790 133e2ed6b9c5
parent 788 78ba80b54bc4
child 791 f1006de05c54
permissions -rw-r--r--
More work on xLinks 
     1 #include <iostream>

     2 #include <QStringList>

     3 

     4 #include "attributeitem.h"

     5 #include "branchobj.h"

     6 #include "branchitem.h"

     7 #include "treeitem.h"

     8 #include "vymmodel.h"

     9 #include "xlinkitem.h"

    10 #include "xlinkobj.h"

    11 

    12 using namespace std;

    13 

    14 extern FlagRow* standardFlagsMaster;

    15 

    16 TreeItem::TreeItem()

    17 {

    18 	//cout << "Constr. TI  this="<<this<<endl;

    19 	init();

    20 	itemData.clear();

    21 	rootItem=this;

    22 	parentItem=NULL;

    23 }

    24 

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

    26 {

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

    28 	init();

    29     parentItem = parent;

    30     itemData = data;

    31 	

    32 	rootItem=this;

    33 	if (parentItem )

    34 		rootItem=parentItem->rootItem;

    35 }

    36 

    37 TreeItem::~TreeItem()

    38 {

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

    40 	TreeItem *ti;

    41 	while (!childItems.isEmpty())

    42 	{

    43 		ti=childItems.takeFirst();

    44 		switch (ti->getType() )

    45 		{

    46 			case TreeItem::MapCenter:

    47 				delete (BranchItem*)ti;

    48 				break;

    49 			case TreeItem::Branch:

    50 				delete (BranchItem*)ti;

    51 				break;

    52 			case TreeItem::Image:

    53 				delete (ImageItem*)ti;

    54 				break;

    55 			case TreeItem::Attribute:

    56 				delete (AttributeItem*)ti;

    57 				break;

    58 			case TreeItem::XLink:

    59 				delete (XLinkItem*)ti;

    60 				break;

    61 			default:

    62 				delete ti;

    63 				break;

    64 		}

    65 	}	

    66 }

    67 

    68 

    69 void TreeItem::init()

    70 {

    71 	model=NULL;

    72 

    73 	branchOffset=0;

    74 	branchCounter=0;

    75 

    76 	imageOffset=0;

    77 	imageCounter=0;

    78 

    79 	attributeCounter=0;

    80 	attributeOffset=0;

    81 

    82 	xlinkCounter=0;

    83 	xlinkOffset=0;

    84 

    85 	note.setNote(""); 

    86 	// note.setFontHint (textEditor->getFontHintDefault() );	//FIXME-3

    87 	// isNoteInEditor=false;

    88 

    89 	hidden=false;

    90 	hideExport=false;

    91 

    92 	// Reset ID

    93 	objID="";

    94 

    95 	standardFlags.setMasterRow (standardFlagsMaster);

    96 }

    97 

    98 

    99 /*

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

   101 

   102 {

   103 	note.copy (other->note);

   104 	model=other->model;

   105 	hideExport=officially 

   106 	other->hideExport;

   107 }

   108 */

   109 

   110 void TreeItem::setModel (VymModel *m)

   111 {

   112 	model=m;

   113 }

   114 

   115 VymModel* TreeItem::getModel ()

   116 {

   117 	return model;

   118 }

   119 

   120 int TreeItem::getRowNumAppend (TreeItem *item)

   121 {	

   122 	switch (item->type)

   123 	{

   124 		case Attribute: return attributeOffset + attributeCounter;

   125 		case XLink: return xlinkOffset + xlinkCounter;

   126 		case Image: return imageOffset + imageCounter;

   127 		case MapCenter: return branchOffset + branchCounter;

   128 		case Branch: return branchOffset + branchCounter;

   129 		default: return -1;

   130 	}

   131 }

   132 

   133 void TreeItem::appendChild(TreeItem *item)

   134 {

   135 	item->parentItem=this;

   136 	item->rootItem=rootItem;

   137 	item->setModel (model);

   138 

   139 	if (item->type == Attribute)

   140 	{

   141 		// attribute are on top of list

   142 		childItems.insert (attributeCounter,item);

   143 		attributeCounter++;

   144 		xlinkOffset++;

   145 		imageOffset++;

   146 		branchOffset++;

   147 	}

   148 

   149 	if (item->type == XLink)

   150 	{

   151 		childItems.insert (xlinkCounter+xlinkOffset,item);

   152 		xlinkCounter++;

   153 		imageOffset++;

   154 		branchOffset++;

   155 	}

   156 

   157 	if (item->type == Image)

   158 	{

   159 		childItems.insert (imageCounter+imageOffset,item);

   160 		imageCounter++;

   161 		branchOffset++;

   162 	}

   163 

   164 	if (item->isBranchLikeType())

   165 	{

   166 		// branches are on bottom of list

   167 		childItems.append(item);

   168 		branchCounter++;

   169 

   170 		// Set correct type		//FIXME-3 DUP in constr branchitem

   171 		if (this==rootItem)

   172 			item->setType(MapCenter);

   173 		else

   174 			item->setType (Branch);

   175 	}

   176 }

   177 

   178 void TreeItem::removeChild(int row)

   179 {

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

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

   182 	else

   183 	{

   184 		if (childItems.at(row)->type==Attribute)

   185 		{

   186 			attributeCounter--;

   187 			xlinkOffset--;

   188 			imageOffset--;

   189 			branchOffset--;

   190 		}	

   191 		if (childItems.at(row)->type==XLink)

   192 		{

   193 			xlinkCounter--;

   194 			imageOffset--;

   195 			branchOffset--;

   196 		}	

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

   198 		{

   199 			imageCounter--;

   200 			branchOffset--;

   201 		}	

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

   203 			branchCounter--;

   204 

   205 		childItems.removeAt (row);

   206 	}

   207 }

   208 

   209 /*

   210 void TreeItem::clear()	// FIXME-2 used in vymmodel addMapInsert, but needs to be used via model and emit layout changes...

   211 {

   212 	cout << "TI::clear\n";

   213 	while ( childItems.size()>0)

   214 	{

   215 		branchCounter--;

   216 		childItems.removeAt (0);

   217 	}

   218 }

   219 */

   220 

   221 TreeItem *TreeItem::child(int row)

   222 {

   223     return childItems.value(row);

   224 }

   225 

   226 int TreeItem::childCount() const

   227 {

   228     return childItems.count();

   229 }

   230 

   231 int TreeItem::childNumber() const

   232 {

   233     if (parentItem)

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

   235 

   236     return 0;

   237 }

   238 

   239 int TreeItem::columnCount() const

   240 {

   241     return itemData.count();

   242 }

   243 

   244 int TreeItem::branchCount() const

   245 {

   246     return branchCounter;

   247 }

   248 

   249 int TreeItem::imageCount() const

   250 {

   251     return imageCounter; 

   252 }

   253 

   254 int TreeItem::xlinkCount() const

   255 {

   256     return xlinkCounter; 

   257 }

   258 

   259 int TreeItem::attributeCount() const 

   260 {

   261     return attributeCounter; 

   262 }

   263 

   264 int TreeItem::row() const

   265 {

   266     if (parentItem)

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

   268 

   269 	cout << "TI::row() pI=NULL this="<<this<<"  ***************\n";

   270     return 0;

   271 }

   272 

   273 int TreeItem::column() const

   274 {

   275     return 0;

   276 }

   277 

   278 int TreeItem::depth() 

   279 {

   280 	// Rootitem d=-1

   281 	// MapCenter d=0

   282 	int d=-2;

   283 	TreeItem *ti=this;

   284 	while (ti!=NULL)

   285 	{

   286 		ti=ti->parent();

   287 		d++;

   288 	}

   289 	return d;

   290 }

   291 

   292 TreeItem *TreeItem::parent()

   293 {

   294     return parentItem;

   295 }

   296 

   297 int TreeItem::childNum()

   298 {

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

   300 }

   301 

   302 int TreeItem::num()

   303 {

   304 	switch (type)

   305 	{

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

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

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

   309 		case Attribute: return parentItem->childItems.indexOf (this) - parentItem->attributeOffset;

   310 		case XLink: return parentItem->childItems.indexOf (this) - parentItem->xlinkOffset;

   311 		default: return -1;

   312 	}

   313 }

   314 

   315 int TreeItem::num (TreeItem *item)

   316 {

   317 	if (!item) return -1;

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

   319 	switch (item->getType())

   320 	{

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

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

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

   324 		case Attribute: return parentItem->childItems.indexOf (item) - attributeOffset;

   325 		case XLink: return parentItem->childItems.indexOf (item) - xlinkOffset;

   326 		default: return -1;

   327 	}

   328 }

   329 void TreeItem::setType(const Type t)

   330 {

   331 	type=t;

   332 	itemData[1]=getTypeName();

   333 }

   334 

   335 TreeItem::Type TreeItem::getType()

   336 {

   337 	if (type==Branch && depth()==0) return MapCenter;	//FIXME-2 should not be necesssary

   338 	return type;

   339 }

   340 

   341 bool TreeItem::isBranchLikeType() const

   342 {

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

   344 	return false;

   345 }

   346 

   347 QString TreeItem::getTypeName()

   348 {

   349 	switch (type)

   350 	{

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

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

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

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

   355 		case Attribute: return QString ("Attribute");

   356 		case XLink: return QString ("XLink");

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

   358 	}

   359 }

   360 

   361 

   362 QVariant TreeItem::data(int column) const

   363 {

   364     return itemData.value(column);

   365 }

   366 

   367 void TreeItem::setHeading (const QString s)

   368 {

   369 	itemData[0]=s;

   370 }

   371 

   372 QString TreeItem::getHeading () const

   373 {

   374 	return itemData[0].toString();

   375 }

   376 

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

   378 {

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

   380 }

   381 

   382 void TreeItem::setHeadingColor (QColor color)

   383 {

   384 	headingColor=color;

   385 }

   386 

   387 QColor TreeItem::getHeadingColor ()

   388 {

   389 	return headingColor;

   390 }

   391 

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

   393 {

   394 	url=u;

   395 	if (!url.isEmpty())

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

   397 	else

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

   399 }

   400 

   401 QString TreeItem::getURL ()

   402 {

   403 	return url;

   404 }

   405 

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

   407 {

   408 	if (!vl.isEmpty())

   409 	{

   410 		// We need the relative (from loading) 

   411 		// or absolute path (from User event)

   412 		// and build the absolute path.

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

   414 		// current map to build absolute path

   415 		QDir d(vl);

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

   417 		{

   418 			QString p=model->getDestPath();

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

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

   421 			d.convertToAbs();

   422 		}

   423 		vymLink=d.path();

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

   425 	}	

   426 	else	

   427 	{

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

   429 		vymLink.clear();

   430 	}	

   431 }

   432 

   433 QString TreeItem::getVymLink ()

   434 {

   435 	return vymLink;

   436 }

   437 

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

   439 {

   440 	NoteObj n;

   441 	n.setNote(s);

   442 	setNoteObj (n,false);

   443 }

   444 

   445 void TreeItem::clearNote()

   446 {

   447 	note.clear();

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

   449 }

   450 

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

   452 	note=n;

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

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

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

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

   457 }

   458 

   459 QString TreeItem::getNote()

   460 {

   461 	return note.getNote();

   462 }

   463 

   464 bool TreeItem::hasEmptyNote()

   465 {

   466 	return note.isEmpty();

   467 }

   468 

   469 NoteObj TreeItem::getNoteObj()

   470 {

   471 	return note;

   472 }

   473 

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

   475 {

   476     return note.getNoteASCII(indent,width);

   477 }

   478 

   479 QString TreeItem::getNoteASCII()

   480 {

   481     return note.getNoteASCII();

   482 }

   483 

   484 QString TreeItem::getNoteOpenDoc()

   485 {

   486     return note.getNoteOpenDoc();

   487 }

   488 

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

   490 {

   491 	standardFlags.activate (name);

   492 	model->emitDataHasChanged(this);

   493 }

   494 

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

   496 {

   497 	standardFlags.deactivate (name);

   498 	model->emitDataHasChanged(this);

   499 }

   500 

   501 void TreeItem::deactivateAllStandardFlags ()

   502 {

   503 	standardFlags.deactivateAll ();

   504 	model->emitDataHasChanged(this);

   505 }

   506 

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

   508 {

   509 	standardFlags.toggle (name,master);

   510 	model->emitDataHasChanged(this);

   511 }

   512 

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

   514 {

   515 	return standardFlags.isActive (name);

   516 }

   517 

   518 QStringList TreeItem::activeStandardFlagNames ()

   519 {

   520 	return standardFlags.activeFlagNames();

   521 }

   522 

   523 FlagRow* TreeItem::getStandardFlagRow()

   524 {

   525 	return &standardFlags;

   526 }

   527 

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

   529 {

   530 	standardFlags.updateToolBar();

   531 }

   532 */

   533 QStringList TreeItem::activeSystemFlagNames ()

   534 {

   535 	return systemFlags.activeFlagNames();

   536 }

   537 

   538 bool TreeItem::canMoveDown()

   539 {

   540 	switch (type)

   541 	{

   542 		case Undefined: return false;

   543 		case MapCenter: 

   544 		case Branch: 

   545 			if (!parentItem) return false;

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

   547 				return true;

   548 			else

   549 				return false;

   550 			break;	

   551 		case Image: return false;

   552 		default: return false;

   553 	}

   554 }

   555 

   556 bool TreeItem::canMoveUp()

   557 {

   558 	switch (type)

   559 	{

   560 		case MapCenter: 

   561 		case Branch: 

   562 			if (!parentItem) return false;

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

   564 				return true;

   565 			else

   566 				return false;

   567 			break;	

   568 		default: return false;

   569 	}

   570 }

   571 

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

   573 {

   574 	objID=s;

   575 }

   576 

   577 QString TreeItem::getID()

   578 {

   579 	return objID;

   580 }

   581 

   582 

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

   584 {

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

   586 		return childItems.at(n);

   587 	else

   588 		return NULL;

   589 }

   590 

   591 BranchItem* TreeItem::getFirstBranch()

   592 {

   593 	if (branchCounter>0)

   594 		return getBranchNum (branchOffset);

   595 	else

   596 		return NULL;

   597 }

   598 

   599 BranchItem* TreeItem::getLastBranch()

   600 {

   601 	if (branchCounter>0)

   602 		return getBranchNum (branchOffset + branchCounter-1);

   603 	else

   604 		return NULL;

   605 }

   606 

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

   608 {

   609 	if (!currentBranch) return NULL;

   610 	int n=num (currentBranch)+1;

   611 	if (n<branchCounter)

   612 		return getBranchNum (branchOffset + n);

   613 	else

   614 		return NULL;

   615 }

   616 

   617 

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

   619 {

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

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

   622 	else

   623 		return NULL;

   624 }

   625 

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

   627 {

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

   629 	{

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

   631 	} else

   632 		return NULL;

   633 }

   634 

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

   636 {

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

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

   639 	else

   640 		return NULL;

   641 }

   642 

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

   644 {

   645 	if (imageCounter>0 )

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

   647 	else

   648 		return NULL;

   649 }

   650 

   651 XLinkItem* TreeItem::getXLinkNum (const int &n)	

   652 {

   653 	if (n>=0 && n<xlinkCounter )

   654 		return (XLinkItem*)getChildNum (xlinkOffset +n);

   655 	else

   656 		return NULL;

   657 }

   658 

   659 

   660 XLinkObj* TreeItem::getXLinkObjNum (const int &n)	

   661 {

   662 	if (xlinkCounter>0 )

   663 	{

   664 		XLinkItem *xli=getXLinkNum (n);

   665 		if (!xli) return NULL;

   666 		if (xli->isBegin() )

   667 			return (XLinkObj*)(xli->getLMO());

   668 		else

   669 		{

   670 			xli=xli->getPartnerXLink();

   671 			if (!xli) return NULL;

   672 			return (XLinkObj*)(xli->getLMO());

   673 		}

   674 	}

   675 	return NULL;

   676 }

   677 

   678 

   679 void TreeItem::setHideTmp (HideTmpMode mode)  //FIXME-2

   680 {

   681 	if (isBranchLikeType() )

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

   683 		/*

   684 	if (type==Image)

   685 		//updateVisibility();

   686 	*/

   687 

   688 /*

   689 

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

   691 		{

   692 			// Hide stuff according to hideExport flag and parents

   693 			//setVisibility (false);

   694 			updateVisibility();

   695 			//FIXME-2 hidden=true;

   696 		}else

   697 		{

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

   699 			

   700 

   701 			XXXXXXXX treeItem should be THIS

   702 

   703 			move visible to TreeItem???

   704 

   705 			BranchObj now has updateContents

   706 

   707 			maybe also start "bool TreeItem::branchlikeType"

   708 

   709 

   710 

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

   712 				setVisibility (false);

   713 			else

   714 				setVisibility (true);

   715 			//FIXME-2 hidden=false;

   716 		}	

   717 

   718 */

   719 		// And take care of my children

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

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

   722 }

   723 

   724 bool TreeItem::hasHiddenExportParent()

   725 {

   726 	// Calls parents recursivly to

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

   728 

   729 	if (hidden || hideExport) return true;

   730 

   731 	if (parentItem) 

   732 		return parentItem->hasHiddenExportParent();

   733 	else

   734 		return false;

   735 }

   736 

   737 

   738 void TreeItem::setHideInExport(bool b) 

   739 {

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

   741 	{

   742 		hideExport=b;

   743 		if (b)

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

   745 		else	

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

   747 	}

   748 }	

   749 

   750 bool TreeItem::hideInExport()

   751 {

   752 	return hideExport;

   753 }	

   754 

   755 bool TreeItem::isHidden()

   756 {

   757 	return hidden;

   758 }	

   759 

   760 QString TreeItem::getGeneralAttr()

   761 {

   762 	QString s;

   763 	if (hideExport)

   764 		 s+=attribut("hideInExport","true");

   765 	if (!url.isEmpty())

   766 		s+=attribut ("url",url);

   767 	if (!vymLink.isEmpty())

   768 		s+=attribut ("vymLink",vymLink);

   769 	return s;	

   770 }

   771 

   772
vym