Mercurialvym / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
treeitem.cpp
author insilmaril
Mon, 14 Jun 2010 13:59:17 +0000
changeset 848 e265f07f2173
parent 847 43268373032d
permissions -rw-r--r--
Fixed tmp relink, colored headings in TreeView 
     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 uint TreeItem::idLast=0;	// Create instance

    17 

    18 TreeItem::TreeItem()

    19 {

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

    21 	init();

    22 	itemData.clear();

    23 	rootItem=this;

    24 	parentItem=NULL;

    25 }

    26 

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

    28 {

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

    30 	init();

    31     parentItem = parent;

    32     itemData = data;

    33 	

    34 	rootItem=this;

    35 	if (parentItem )

    36 		rootItem=parentItem->rootItem;

    37 }

    38 

    39 TreeItem::~TreeItem()

    40 {

    41 	//qDebug()<<"Destr TreeItem this="<<this<<"  childcount="<<childItems.count();

    42 	/*

    43 	qDeleteAll(childItems);	// Call delete	//FIXME-3 use this instead of below

    44 	qDebug()<<"  ok1";

    45 	childItems.clear();		// and clear list

    46 	qDebug()<<"  ok2";use

    47 	*/

    48 

    49 	/*

    50 	if (this==rootItem)

    51 	{

    52 		qDebug()<<"  I'm rootItem, aborting";

    53 		return;

    54 	}

    55 	*/

    56 	//qDebug()<<"                   ="<<getHeading();

    57 	TreeItem *ti;

    58 	while (!childItems.isEmpty())

    59 	{

    60 		//qDebug()<<"    ="<<ti->getHeading();

    61 		ti=childItems.takeFirst();

    62 		//qDebug()<<"  ti="<<ti;

    63 		delete ti;

    64 	}

    65 }

    66 

    67 

    68 void TreeItem::init()

    69 {

    70 	model=NULL;

    71 

    72 	// Assign ID  

    73 	idLast++;

    74 	id=idLast;

    75 

    76 	branchOffset=0;

    77 	branchCounter=0;

    78 

    79  	imageOffset=0;

    80 	imageCounter=0;

    81 

    82 	attributeCounter=0;

    83 	attributeOffset=0;

    84 

    85 	xlinkCounter=0;

    86 	xlinkOffset=0;

    87 

    88 	note.setNote(""); 

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

    90 	// isNoteInEditor=false;

    91 

    92 	hidden=false;

    93 	hideExport=false;

    94 

    95 	standardFlags.setMasterRow (standardFlagsMaster);

    96 }

    97 

    98 

    99 void TreeItem::setModel (VymModel *m)

   100 {

   101 	model=m;

   102 }

   103 

   104 VymModel* TreeItem::getModel ()

   105 {

   106 	return model;

   107 }

   108 

   109 int TreeItem::getRowNumAppend (TreeItem *item)

   110 {	

   111 	switch (item->type)

   112 	{

   113 		case Attribute: return attributeOffset + attributeCounter;

   114 		case XLink: return xlinkOffset + xlinkCounter;

   115 		case Image: return imageOffset + imageCounter;

   116 		case MapCenter: return branchOffset + branchCounter;

   117 		case Branch: return branchOffset + branchCounter;

   118 		default: return -1;

   119 	}

   120 }

   121 

   122 void TreeItem::appendChild(TreeItem *item)

   123 {

   124 	item->parentItem=this;

   125 	item->rootItem=rootItem;

   126 	item->setModel (model);

   127 

   128 	if (item->type == Attribute)

   129 	{

   130 		// attribute are on top of list

   131 		childItems.insert (attributeCounter,item);

   132 		attributeCounter++;

   133 		xlinkOffset++;

   134 		imageOffset++;

   135 		branchOffset++;

   136 	}

   137 

   138 	if (item->type == XLink)

   139 	{

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

   141 		xlinkCounter++;

   142 		imageOffset++;

   143 		branchOffset++;

   144 	}

   145 

   146 	if (item->type == Image)

   147 	{

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

   149 		imageCounter++;

   150 		branchOffset++;

   151 	}

   152 

   153 	if (item->isBranchLikeType())

   154 	{

   155 		// branches are on bottom of list

   156 		childItems.append(item);

   157 		branchCounter++;

   158 

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

   160 		if (this==rootItem)

   161 			item->setType(MapCenter);

   162 		else

   163 			item->setType (Branch);

   164 	}

   165 }

   166 

   167 void TreeItem::removeChild(int row)

   168 {

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

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

   171 	else

   172 	{

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

   174 		{

   175 			attributeCounter--;

   176 			xlinkOffset--;

   177 			imageOffset--;

   178 			branchOffset--;

   179 		}	

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

   181 		{

   182 			xlinkCounter--;

   183 			imageOffset--;

   184 			branchOffset--;

   185 		}	

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

   187 		{

   188 			imageCounter--;

   189 			branchOffset--;

   190 		}	

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

   192 			branchCounter--;

   193 

   194 		childItems.removeAt (row);

   195 	}

   196 }

   197 

   198 TreeItem *TreeItem::child(int row)

   199 {

   200     return childItems.value(row);

   201 }

   202 

   203 int TreeItem::childCount() const

   204 {

   205     return childItems.count();

   206 }

   207 

   208 int TreeItem::childNumber() const

   209 {

   210     if (parentItem)

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

   212 

   213     return 0;

   214 }

   215 

   216 int TreeItem::columnCount() const

   217 {

   218 	return 1;

   219 }

   220 

   221 int TreeItem::branchCount() const

   222 {

   223     return branchCounter;

   224 }

   225 

   226 int TreeItem::imageCount() const

   227 {

   228     return imageCounter; 

   229 }

   230 

   231 int TreeItem::xlinkCount() const

   232 {

   233     return xlinkCounter; 

   234 }

   235 

   236 int TreeItem::attributeCount() const 

   237 {

   238     return attributeCounter; 

   239 }

   240 

   241 int TreeItem::row() const

   242 {

   243     if (parentItem)

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

   245 

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

   247     return 0;

   248 }

   249 

   250 int TreeItem::depth() 

   251 {

   252 	// Rootitem d=-1

   253 	// MapCenter d=0

   254 	int d=-2;

   255 	TreeItem *ti=this;

   256 	while (ti!=NULL)

   257 	{

   258 		ti=ti->parent();

   259 		d++;

   260 	}

   261 	return d;

   262 }

   263 

   264 TreeItem *TreeItem::parent()

   265 {

   266 	//cout << "TI::parent of "<<getHeadingStd()<<"  is "<<parentItem<<endl;

   267     return parentItem;

   268 }

   269 

   270 int TreeItem::childNum()

   271 {

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

   273 }

   274 

   275 int TreeItem::num()

   276 {

   277 	if (!parentItem) return -1;

   278 	return parentItem->num (this);

   279 }

   280 

   281 int TreeItem::num (TreeItem *item)

   282 {

   283 	if (!item) return -1;

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

   285 	switch (item->getType())

   286 	{

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

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

   289 		case Image: return childItems.indexOf (item) - imageOffset;

   290 		case Attribute: return childItems.indexOf (item) - attributeOffset;

   291 		case XLink: return childItems.indexOf (item) - xlinkOffset;

   292 		default: return -1;

   293 	}

   294 }

   295 void TreeItem::setType(const Type t)

   296 {

   297 	type=t;

   298 	itemData[1]=getTypeName();

   299 }

   300 

   301 TreeItem::Type TreeItem::getType()

   302 {

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

   304 	return type;

   305 }

   306 

   307 bool TreeItem::isBranchLikeType() const

   308 {

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

   310 	return false;

   311 }

   312 

   313 QString TreeItem::getTypeName()

   314 {

   315 	switch (type)

   316 	{

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

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

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

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

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

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

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

   324 	}

   325 }

   326 

   327 

   328 QVariant TreeItem::data(int column) const

   329 {

   330     return itemData.value(column);

   331 }

   332 

   333 void TreeItem::setHeading (const QString s)

   334 {

   335 	itemData[0]=s;

   336 	//qDebug()<<"TI::setHeading this="<<this<<"  "<<s;

   337 }

   338 

   339 QString TreeItem::getHeading () const

   340 {

   341 	return itemData[0].toString();

   342 }

   343 

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

   345 {

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

   347 }

   348 

   349 void TreeItem::setHeadingColor (QColor color)

   350 {

   351 	headingColor=color;

   352 }

   353 

   354 QColor TreeItem::getHeadingColor ()

   355 {

   356 	return headingColor;

   357 }

   358 

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

   360 {

   361 	url=u;

   362 	if (!url.isEmpty())

   363 	{

   364 		if (url.contains ("bugzilla.novell.com"))

   365 		{

   366 			systemFlags.activate ("system-url-bugzilla-novell");

   367 			if (systemFlags.isActive ("system-url"))

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

   369 		} else

   370 		{

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

   372 			if (systemFlags.isActive ("system-url-bugzilla-novell"))

   373 				systemFlags.deactivate ("system-url-bugzilla-novell");

   374 		}

   375 	}

   376 	else

   377 	{

   378 		if (systemFlags.isActive ("system-url"))

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

   380 		if (systemFlags.isActive ("system-url-bugzilla-novell"))

   381 			systemFlags.deactivate ("system-url-bugzilla-novell");

   382 	}

   383 }

   384 

   385 QString TreeItem::getURL ()

   386 {

   387 	return url;

   388 }

   389 

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

   391 {

   392 	if (!vl.isEmpty())

   393 	{

   394 		// We need the relative (from loading) 

   395 		// or absolute path (from User event)

   396 		// and build the absolute path.

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

   398 		// current map to build absolute path

   399 		QDir d(vl);

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

   401 		{

   402 			QString p=model->getDestPath();

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

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

   405 			d.convertToAbs();

   406 		}

   407 		vymLink=d.path();

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

   409 	}	

   410 	else	

   411 	{

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

   413 		vymLink.clear();

   414 	}	

   415 }

   416 

   417 QString TreeItem::getVymLink ()

   418 {

   419 	return vymLink;

   420 }

   421 

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

   423 {

   424 	NoteObj n;

   425 	n.setNote(s);

   426 	setNoteObj (n);

   427 }

   428 

   429 void TreeItem::clearNote()

   430 {

   431 	note.clear();

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

   433 }

   434 

   435 void TreeItem::setNoteObj(const NoteObj &n){

   436 	note=n;

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

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

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

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

   441 }

   442 

   443 QString TreeItem::getNote()

   444 {

   445 	return note.getNote();

   446 }

   447 

   448 bool TreeItem::hasEmptyNote()

   449 {

   450 	return note.isEmpty();

   451 }

   452 

   453 NoteObj TreeItem::getNoteObj()

   454 {

   455 	return note;

   456 }

   457 

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

   459 {

   460     return note.getNoteASCII(indent,width);

   461 }

   462 

   463 QString TreeItem::getNoteASCII()

   464 {

   465     return note.getNoteASCII();

   466 }

   467 

   468 QString TreeItem::getNoteOpenDoc()

   469 {

   470     return note.getNoteOpenDoc();

   471 }

   472 

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

   474 {

   475 	standardFlags.activate (name);

   476 	model->emitDataHasChanged(this);

   477 }

   478 

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

   480 {

   481 	standardFlags.deactivate (name);

   482 	model->emitDataHasChanged(this);

   483 }

   484 

   485 void TreeItem::deactivateAllStandardFlags ()

   486 {

   487 	standardFlags.deactivateAll ();

   488 	model->emitDataHasChanged(this);

   489 }

   490 

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

   492 {

   493 	standardFlags.toggle (name,master);

   494 	model->emitDataHasChanged(this);

   495 }

   496 

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

   498 {

   499 	return standardFlags.isActive (name);

   500 }

   501 

   502 QStringList TreeItem::activeStandardFlagNames ()

   503 {

   504 	return standardFlags.activeFlagNames();

   505 }

   506 

   507 FlagRow* TreeItem::getStandardFlagRow()

   508 {

   509 	return &standardFlags;

   510 }

   511 

   512 QStringList TreeItem::activeSystemFlagNames ()

   513 {

   514 	return systemFlags.activeFlagNames();

   515 }

   516 

   517 bool TreeItem::canMoveDown()

   518 {

   519 	switch (type)

   520 	{

   521 		case Undefined: return false;

   522 		case MapCenter: 

   523 		case Branch: 

   524 			if (!parentItem) return false;

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

   526 				return true;

   527 			else

   528 				return false;

   529 			break;	

   530 		case Image: return false;

   531 		default: return false;

   532 	}

   533 }

   534 

   535 bool TreeItem::canMoveUp()

   536 {

   537 	switch (type)

   538 	{

   539 		case MapCenter: 

   540 		case Branch: 

   541 			if (!parentItem) return false;

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

   543 				return true;

   544 			else

   545 				return false;

   546 			break;	

   547 		default: return false;

   548 	}

   549 }

   550 

   551 uint TreeItem::getID()

   552 {

   553 	return id;

   554 }

   555 

   556 TreeItem* TreeItem::findID (const uint &n)

   557 {

   558 	for (int i=0;i<childItems.count(); i++)

   559 		if (n==childItems.at(i)->id)

   560 			return childItems.at(n);

   561 	return NULL;

   562 }

   563 

   564 

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

   566 {

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

   568 		return childItems.at(n);

   569 	else

   570 		return NULL;

   571 }

   572 

   573 BranchItem* TreeItem::getFirstBranch()

   574 {

   575 	if (branchCounter>0)

   576 		return getBranchNum (0);

   577 	else

   578 		return NULL;

   579 }

   580 

   581 BranchItem* TreeItem::getLastBranch()

   582 {

   583 	if (branchCounter>0)

   584 		return getBranchNum (branchCounter-1);

   585 	else

   586 		return NULL;

   587 }

   588 

   589 ImageItem* TreeItem::getFirstImage()

   590 {

   591 	if (imageCounter>0)

   592 		return getImageNum (imageCounter-1);

   593 	else

   594 		return NULL;

   595 }

   596 

   597 ImageItem* TreeItem::getLastImage()

   598 {

   599 	if (imageCounter>0)

   600 		return getImageNum (imageCounter-1);

   601 	else

   602 		return NULL;

   603 }

   604 

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

   606 {

   607 	if (!currentBranch) return NULL;

   608 	int n=num (currentBranch)+1;

   609 	if (n<branchCounter)

   610 		return getBranchNum (branchOffset + n);

   611 	else

   612 		return NULL;

   613 }

   614 

   615 

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

   617 {

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

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

   620 	else

   621 		return NULL;

   622 }

   623 

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

   625 {

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

   627 	{

   628 		BranchItem *bi=getBranchNum(n);

   629 		if (bi)

   630 		{

   631 			BranchObj *bo=(BranchObj*)(bi->getLMO());

   632 			if (bo)

   633 				return bo;

   634 			else

   635 				qDebug()<<"TI::getBONum bo=NULL";

   636 		}

   637 	} 

   638 	return NULL;

   639 }

   640 

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

   642 {

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

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

   645 	else

   646 		return NULL;

   647 }

   648 

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

   650 {

   651 	if (imageCounter>0 )

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

   653 	else

   654 		return NULL;

   655 }

   656 

   657 AttributeItem* TreeItem::getAttributeNum (const int &n)

   658 {

   659 	if (n>=0 && n<attributeCounter)

   660 		return (AttributeItem*)getChildNum (attributeOffset + n);

   661 	else

   662 		return NULL;

   663 }

   664 

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

   666 {

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

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

   669 	else

   670 		return NULL;

   671 }

   672 

   673 

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

   675 {

   676 	if (xlinkCounter>0 )

   677 	{

   678 		XLinkItem *xli=getXLinkNum (n);

   679 		if (xli)

   680 		{

   681 			Link *l=xli->getLink();

   682 			if (l) return l->getXLinkObj();

   683 		}

   684 	}

   685 	return NULL;

   686 }

   687 

   688 

   689 void TreeItem::setHideTmp (HideTmpMode mode)  //FIXME-3	update visibility in derived objects

   690 {

   691 	if (type==Image || type==Branch || type==MapCenter)

   692 //		((ImageItem*)this)->updateVisibility();

   693 	{

   694 		//LinkableMapObj* lmo=((MapItem*)this)->getLMO();

   695 

   696 		if (mode==HideExport && (hideExport || hasHiddenExportParent() ) ) // FIXME-3  try to avoid calling hasScrolledParent repeatedly

   697 

   698 		{

   699 			// Hide stuff according to hideExport flag and parents

   700 			hidden=true;

   701 			//if (lmo) lmo->setVisibility (false);

   702 			updateVisibility();	// FIXME-3 missing for images

   703 		}else

   704 		{

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

   706 			hidden=false;

   707 			updateVisibility();

   708 		}

   709 		// And take care of my children

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

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

   712 	}

   713 }

   714 

   715 bool TreeItem::hasHiddenExportParent()

   716 {

   717 	// Calls parents recursivly to

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

   719 

   720 	if (hidden || hideExport) return true;

   721 

   722 	if (parentItem) 

   723 		return parentItem->hasHiddenExportParent();

   724 	else

   725 		return false;

   726 }

   727 

   728 

   729 void TreeItem::setHideInExport(bool b) 

   730 {

   731 	if (type==MapCenter ||type==Branch || type==Image)

   732 	{

   733 		hideExport=b;

   734 		if (b)

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

   736 		else	

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

   738 	}

   739 }	

   740 

   741 bool TreeItem::hideInExport()

   742 {

   743 	return hideExport;

   744 }	

   745 

   746 void TreeItem::updateVisibility()

   747 {

   748 	// overloaded in derived objects

   749 }	

   750 

   751 bool TreeItem::isHidden()

   752 {

   753 	return hidden;

   754 }	

   755 

   756 QString TreeItem::getGeneralAttr()	

   757 {

   758 	QString s;

   759 	if (hideExport)

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

   761 	if (!url.isEmpty())

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

   763 	if (!vymLink.isEmpty())

   764 		s+=attribut ("vymLink",convertToRel (model->getDestPath(),vymLink));

   765 	return s;	

   766 }

   767 

   768
vym