vym: treeitem.cpp@6269016c9905

     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 	attributeCounter=0;

    76 	attributeOffset=0;

    78 	note.setNote("");

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

    80 	// isNoteInEditor=false;

    82 	hidden=false;

    83 	hideExport=false;

    85 	// Reset ID

    86 	objID="";

    88 	standardFlags.setMasterRow (standardFlagsMaster);

    89 }

    92 /*

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

    95 {

    96 	note.copy (other->note);

    97 	model=other->model;

    98 	hideExport=officially

    99 	other->hideExport;

   100 }

   101 */

   103 void TreeItem::setModel (VymModel *m)

   104 {

   105 	model=m;

   106 }

   108 VymModel* TreeItem::getModel ()

   109 {

   110 	return model;

   111 }

   113 int TreeItem::getRowNumAppend (TreeItem *item)

   114 {

   115 	switch (item->type)

   116 	{

   117 		case Attribute: return attributeOffset + attributeCounter;

   118 		case Image: return imageOffset + imageCounter;

   119 		case MapCenter: return branchOffset + branchCounter;

   120 		case Branch: return branchOffset + branchCounter;

   121 		default: return -1;

   122 	}

   123 }

   125 void TreeItem::appendChild(TreeItem *item)

   126 {

   127 	item->parentItem=this;

   128 	item->rootItem=rootItem;

   129 	item->setModel (model);

   131 	if (item->type == Attribute)

   132 	{

   133 		// attribute are on top of list

   134 		childItems.insert (attributeCounter,item);

   135 		attributeCounter++;

   136 		imageOffset++;

   137 		branchOffset++;

   138 	}

   140 	if (item->type == Image)

   141 	{

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

   143 		imageCounter++;

   144 		branchOffset++;

   145 	}

   147 	if (item->isBranchLikeType())

   148 	{

   149 		// branches are on bottom of list

   150 		childItems.append(item);

   151 		branchCounter++;

   152 	}

   153 }

   155 void TreeItem::removeChild(int row)

   156 {

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

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

   159 	else

   160 	{

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

   162 		{

   163 			attributeCounter--;

   164 			imageOffset--;

   165 			branchOffset--;

   166 		}

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

   168 		{

   169 			imageCounter--;

   170 			branchOffset--;

   171 		}

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

   173 			branchCounter--;

   175 		childItems.removeAt (row);

   176 	}

   177 }

   179 void TreeItem::removeChildBranches()

   180 {

   181 	while ( childItems.size()>0)

   182 	{

   183 		branchCounter--;

   184 		childItems.removeAt (0);

   185 	}

   186 }

   188 TreeItem *TreeItem::child(int row)

   189 {

   190     return childItems.value(row);

   191 }

   193 int TreeItem::childCount() const

   194 {

   195     return childItems.count();

   196 }

   198 int TreeItem::childNumber() const

   199 {

   200     if (parentItem)

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

   203     return 0;

   204 }

   206 int TreeItem::columnCount() const

   207 {

   208     return itemData.count();

   209 }

   211 int TreeItem::branchCount() const

   212 {

   213     return branchCounter;

   214 }

   216 int TreeItem::imageCount() const

   217 {

   218     return imageCounter;

   219 }

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

   222 {

   223 	int xlinkCounter=0;

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

   225 }

   227 int TreeItem::attributeCount() const

   228 {

   229     return attributeCounter;

   230 }

   232 int TreeItem::row() const

   233 {

   234     if (parentItem)

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

   237     return 0;

   238 }

   240 int TreeItem::column() const

   241 {

   242     return 0;

   243 }

   245 int TreeItem::depth()

   246 {

   247 	int d=-2;

   248 	TreeItem *ti=this;

   249 	while (ti!=NULL)

   250 	{

   251 		ti=ti->parent();

   252 		d++;

   253 	}

   254 	return d;

   255 }

   257 TreeItem *TreeItem::parent()

   258 {

   259     return parentItem;

   260 }

   262 int TreeItem::childNum()

   263 {

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

   265 }

   267 int TreeItem::num()

   268 {

   269 	switch (type)

   270 	{

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

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

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

   274 		default: return -1;

   275 	}

   276 }

   278 int TreeItem::num (TreeItem *item)

   279 {

   280 	if (!item) return -1;

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

   282 	switch (item->getType())

   283 	{

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

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

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

   287 		default: return -1;

   288 	}

   289 }

   290 void TreeItem::setType(const Type t)

   291 {

   292 	type=t;

   293 	itemData[1]=getTypeName();

   294 }

   296 TreeItem::Type TreeItem::getType()

   297 {

   298 	return type;

   299 }

   301 bool TreeItem::isBranchLikeType() const

   302 {

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

   304 	return false;

   305 }

   307 QString TreeItem::getTypeName()

   308 {

   309 	switch (type)

   310 	{

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

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

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

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

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

   316 	}

   317 }

   320 QVariant TreeItem::data(int column) const

   321 {

   322     return itemData.value(column);

   323 }

   325 void TreeItem::setHeading (const QString s)

   326 {

   327 	itemData[0]=s;

   328 }

   330 QString TreeItem::getHeading () const

   331 {

   332 	return itemData[0].toString();

   333 }

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

   336 {

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

   338 }

   340 void TreeItem::setHeadingColor (QColor color)

   341 {

   342 	headingColor=color;

   343 }

   345 QColor TreeItem::getHeadingColor ()

   346 {

   347 	return headingColor;

   348 }

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

   351 {

   352 	url=u;

   353 	if (!url.isEmpty())

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

   355 	else

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

   357 }

   359 QString TreeItem::getURL ()

   360 {

   361 	return url;

   362 }

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

   365 {

   366 	if (!vl.isEmpty())

   367 	{

   368 		// We need the relative (from loading)

   369 		// or absolute path (from User event)

   370 		// and build the absolute path.

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

   372 		// current map to build absolute path

   373 		QDir d(vl);

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

   375 		{

   376 			QString p=model->getDestPath();

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

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

   379 			d.convertToAbs();

   380 		}

   381 		vymLink=d.path();

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

   383 	}

   384 	else

   385 	{

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

   387 		vymLink.clear();

   388 	}

   389 }

   391 QString TreeItem::getVymLink ()

   392 {

   393 	return vymLink;

   394 }

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

   397 {

   398 	NoteObj n;

   399 	n.setNote(s);

   400 	setNoteObj (n,false);

   401 }

   403 void TreeItem::clearNote()

   404 {

   405 	note.clear();

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

   407 }

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

   410 	note=n;

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

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

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

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

   415 }

   417 QString TreeItem::getNote()

   418 {

   419 	return note.getNote();

   420 }

   422 bool TreeItem::hasEmptyNote()

   423 {

   424 	return note.isEmpty();

   425 }

   427 NoteObj TreeItem::getNoteObj()

   428 {

   429 	return note;

   430 }

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

   433 {

   434     return note.getNoteASCII(indent,width);

   435 }

   437 QString TreeItem::getNoteASCII()

   438 {

   439     return note.getNoteASCII();

   440 }

   442 QString TreeItem::getNoteOpenDoc()

   443 {

   444     return note.getNoteOpenDoc();

   445 }

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

   448 {

   449 	standardFlags.activate (name);

   450 	model->emitDataHasChanged(this);

   451 }

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

   454 {

   455 	standardFlags.deactivate (name);

   456 	model->emitDataHasChanged(this);

   457 }

   459 void TreeItem::deactivateAllStandardFlags ()

   460 {

   461 	standardFlags.deactivateAll ();

   462 	model->emitDataHasChanged(this);

   463 }

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

   466 {

   467 	standardFlags.toggle (name,master);

   468 	model->emitDataHasChanged(this);

   469 }

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

   472 {

   473 	return standardFlags.isActive (name);

   474 }

   476 QStringList TreeItem::activeStandardFlagNames ()

   477 {

   478 	return standardFlags.activeFlagNames();

   479 }

   481 FlagRow* TreeItem::getStandardFlagRow()

   482 {

   483 	return &standardFlags;

   484 }

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

   487 {

   488 	standardFlags.updateToolBar();

   489 }

   490 */

   491 QStringList TreeItem::activeSystemFlagNames ()

   492 {

   493 	return systemFlags.activeFlagNames();

   494 }

   496 bool TreeItem::canMoveDown()

   497 {

   498 	switch (type)

   499 	{

   500 		case Undefined: return false;

   501 		case MapCenter:

   502 		case Branch:

   503 			if (!parentItem) return false;

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

   505 				return true;

   506 			else

   507 				return false;

   508 			break;

   509 		case Image: return false;

   510 		default: return false;

   511 	}

   512 }

   514 bool TreeItem::canMoveUp()

   515 {

   516 	switch (type)

   517 	{

   518 		case Undefined: return false;

   519 		case MapCenter:

   520 		case Branch:

   521 			if (!parentItem) return false;

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

   523 				return true;

   524 			else

   525 				return false;

   526 			break;

   527 		case Image: return false;

   528 		default: return false;

   529 	}

   530 }

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

   533 {

   534 	objID=s;

   535 }

   537 QString TreeItem::getID()

   538 {

   539 	return objID;

   540 }

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

   544 {

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

   546 		return childItems.at(n);

   547 	else

   548 		return NULL;

   549 }

   551 BranchItem* TreeItem::getFirstBranch()

   552 {

   553 	if (branchCounter>0)

   554 		return getBranchNum (branchOffset);

   555 	else

   556 		return NULL;

   557 }

   559 BranchItem* TreeItem::getLastBranch()

   560 {

   561 	if (branchCounter>0)

   562 		return getBranchNum (branchOffset + branchCounter-1);

   563 	else

   564 		return NULL;

   565 }

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

   568 {

   569 	if (!currentBranch) return NULL;

   570 	int n=num (currentBranch)+1;

   571 	if (n<branchCounter)

   572 		return getBranchNum (branchOffset + n);

   573 	else

   574 		return NULL;

   575 }

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

   579 {

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

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

   582 	else

   583 		return NULL;

   584 }

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

   587 {

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

   589 	{

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

   591 	} else

   592 		return NULL;

   593 }

   595 void TreeItem::setLastSelectedBranch()

   596 {

   597 	if (parentItem)

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

   599 }

   601 void TreeItem::setLastSelectedBranch(int i)

   602 {

   603 		lastSelectedBranchNum=i;

   604 }

   606 TreeItem* TreeItem::getLastSelectedBranch()

   607 {

   608 	return getBranchNum (lastSelectedBranchNum);

   609 }

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

   612 {

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

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

   615 	else

   616 		return NULL;

   617 }

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

   620 {

   621 	if (imageCounter>0 )

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

   623 	else

   624 		return NULL;

   625 }

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

   629 {

   630 	if (isBranchLikeType() )

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

   632 		/*

   633 	if (type==Image)

   634 		//updateVisibility();

   635 	*/

   637 /*

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

   640 		{

   641 			// Hide stuff according to hideExport flag and parents

   642 			//setVisibility (false);

   643 			updateVisibility();

   644 			//FIXME-2 hidden=true;

   645 		}else

   646 		{

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

   650 			XXXXXXXX treeItem should be THIS

   652 			move visible to TreeItem???

   654 			BranchObj now has updateContents

   656 			maybe also start "bool TreeItem::branchlikeType"

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

   661 				setVisibility (false);

   662 			else

   663 				setVisibility (true);

   664 			//FIXME-2 hidden=false;

   665 		}

   667 */

   668 		// And take care of my children

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

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

   671 }

   673 bool TreeItem::hasHiddenExportParent()

   674 {

   675 	// Calls parents recursivly to

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

   678 	if (hidden || hideExport) return true;

   680 	if (parentItem)

   681 		return parentItem->hasHiddenExportParent();

   682 	else

   683 		return false;

   684 }

   687 void TreeItem::setHideInExport(bool b)

   688 {

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

   690 	{

   691 		hideExport=b;

   692 		if (b)

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

   694 		else

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

   696 	}

   697 }

   699 bool TreeItem::hideInExport()

   700 {

   701 	return hideExport;

   702 }

   704 bool TreeItem::isHidden()

   705 {

   706 	return hidden;

   707 }

   709 QString TreeItem::getGeneralAttr()

   710 {

   711 	QString s;

   712 	if (hideExport)

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

   714 	if (!url.isEmpty())

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

   716 	if (!vymLink.isEmpty())

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

   718 	return s;

   719 }

author	insilmaril
	Thu, 06 Aug 2009 10:42:17 +0000
changeset 786	6269016c9905
parent 781	6cbf3c9cbd21
child 787	c6bb4fdcc55f
permissions	-rw-r--r--