vym: treeitem.cpp@c6bb4fdcc55f

     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;

    71 	imageOffset=0;

    72 	imageCounter=0;

    74 	attributeCounter=0;

    75 	attributeOffset=0;

    77 	note.setNote("");

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

    79 	// isNoteInEditor=false;

    81 	hidden=false;

    82 	hideExport=false;

    84 	// Reset ID

    85 	objID="";

    87 	standardFlags.setMasterRow (standardFlagsMaster);

    88 }

    91 /*

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

    94 {

    95 	note.copy (other->note);

    96 	model=other->model;

    97 	hideExport=officially

    98 	other->hideExport;

    99 }

   100 */

   102 void TreeItem::setModel (VymModel *m)

   103 {

   104 	model=m;

   105 }

   107 VymModel* TreeItem::getModel ()

   108 {

   109 	return model;

   110 }

   112 int TreeItem::getRowNumAppend (TreeItem *item)

   113 {

   114 	switch (item->type)

   115 	{

   116 		case Attribute: return attributeOffset + attributeCounter;

   117 		case Image: return imageOffset + imageCounter;

   118 		case MapCenter: return branchOffset + branchCounter;

   119 		case Branch: return branchOffset + branchCounter;

   120 		default: return -1;

   121 	}

   122 }

   124 void TreeItem::appendChild(TreeItem *item)

   125 {

   126 	item->parentItem=this;

   127 	item->rootItem=rootItem;

   128 	item->setModel (model);

   130 	if (item->type == Attribute)

   131 	{

   132 		// attribute are on top of list

   133 		childItems.insert (attributeCounter,item);

   134 		attributeCounter++;

   135 		imageOffset++;

   136 		branchOffset++;

   137 	}

   139 	if (item->type == Image)

   140 	{

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

   142 		imageCounter++;

   143 		branchOffset++;

   144 	}

   146 	if (item->isBranchLikeType())

   147 	{

   148 		// branches are on bottom of list

   149 		childItems.append(item);

   150 		branchCounter++;

   151 	}

   152 }

   154 void TreeItem::removeChild(int row)

   155 {

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

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

   158 	else

   159 	{

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

   161 		{

   162 			attributeCounter--;

   163 			imageOffset--;

   164 			branchOffset--;

   165 		}

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

   167 		{

   168 			imageCounter--;

   169 			branchOffset--;

   170 		}

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

   172 			branchCounter--;

   174 		childItems.removeAt (row);

   175 	}

   176 }

   178 void TreeItem::removeChildBranches()

   179 {

   180 	while ( childItems.size()>0)

   181 	{

   182 		branchCounter--;

   183 		childItems.removeAt (0);

   184 	}

   185 }

   187 TreeItem *TreeItem::child(int row)

   188 {

   189     return childItems.value(row);

   190 }

   192 int TreeItem::childCount() const

   193 {

   194     return childItems.count();

   195 }

   197 int TreeItem::childNumber() const

   198 {

   199     if (parentItem)

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

   202     return 0;

   203 }

   205 int TreeItem::columnCount() const

   206 {

   207     return itemData.count();

   208 }

   210 int TreeItem::branchCount() const

   211 {

   212     return branchCounter;

   213 }

   215 int TreeItem::imageCount() const

   216 {

   217     return imageCounter;

   218 }

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

   221 {

   222 	int xlinkCounter=0;

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

   224 }

   226 int TreeItem::attributeCount() const

   227 {

   228     return attributeCounter;

   229 }

   231 int TreeItem::row() const

   232 {

   233     if (parentItem)

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

   236     return 0;

   237 }

   239 int TreeItem::column() const

   240 {

   241     return 0;

   242 }

   244 int TreeItem::depth()

   245 {

   246 	// Rootitem d=-1

   247 	// MapCenter d=0

   248 	int d=-2;

   249 	TreeItem *ti=this;

   250 	while (ti!=NULL)

   251 	{

   252 		ti=ti->parent();

   253 		d++;

   254 	}

   255 	return d;

   256 }

   258 TreeItem *TreeItem::parent()

   259 {

   260     return parentItem;

   261 }

   263 int TreeItem::childNum()

   264 {

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

   266 }

   268 int TreeItem::num()

   269 {

   270 	switch (type)

   271 	{

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

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

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

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

   276 		default: return -1;

   277 	}

   278 }

   280 int TreeItem::num (TreeItem *item)

   281 {

   282 	if (!item) return -1;

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

   284 	switch (item->getType())

   285 	{

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

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

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

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

   290 		default: return -1;

   291 	}

   292 }

   293 void TreeItem::setType(const Type t)

   294 {

   295 	type=t;

   296 	itemData[1]=getTypeName();

   297 }

   299 TreeItem::Type TreeItem::getType()

   300 {

   301 	if (type==Branch && depth()==0) return MapCenter;

   302 	return type;

   303 }

   305 bool TreeItem::isBranchLikeType() const

   306 {

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

   308 	return false;

   309 }

   311 QString TreeItem::getTypeName()

   312 {

   313 	switch (type)

   314 	{

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

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

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

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

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

   320 	}

   321 }

   324 QVariant TreeItem::data(int column) const

   325 {

   326     return itemData.value(column);

   327 }

   329 void TreeItem::setHeading (const QString s)

   330 {

   331 	itemData[0]=s;

   332 }

   334 QString TreeItem::getHeading () const

   335 {

   336 	return itemData[0].toString();

   337 }

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

   340 {

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

   342 }

   344 void TreeItem::setHeadingColor (QColor color)

   345 {

   346 	headingColor=color;

   347 }

   349 QColor TreeItem::getHeadingColor ()

   350 {

   351 	return headingColor;

   352 }

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

   355 {

   356 	url=u;

   357 	if (!url.isEmpty())

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

   359 	else

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

   361 }

   363 QString TreeItem::getURL ()

   364 {

   365 	return url;

   366 }

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

   369 {

   370 	if (!vl.isEmpty())

   371 	{

   372 		// We need the relative (from loading)

   373 		// or absolute path (from User event)

   374 		// and build the absolute path.

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

   376 		// current map to build absolute path

   377 		QDir d(vl);

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

   379 		{

   380 			QString p=model->getDestPath();

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

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

   383 			d.convertToAbs();

   384 		}

   385 		vymLink=d.path();

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

   387 	}

   388 	else

   389 	{

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

   391 		vymLink.clear();

   392 	}

   393 }

   395 QString TreeItem::getVymLink ()

   396 {

   397 	return vymLink;

   398 }

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

   401 {

   402 	NoteObj n;

   403 	n.setNote(s);

   404 	setNoteObj (n,false);

   405 }

   407 void TreeItem::clearNote()

   408 {

   409 	note.clear();

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

   411 }

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

   414 	note=n;

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

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

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

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

   419 }

   421 QString TreeItem::getNote()

   422 {

   423 	return note.getNote();

   424 }

   426 bool TreeItem::hasEmptyNote()

   427 {

   428 	return note.isEmpty();

   429 }

   431 NoteObj TreeItem::getNoteObj()

   432 {

   433 	return note;

   434 }

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

   437 {

   438     return note.getNoteASCII(indent,width);

   439 }

   441 QString TreeItem::getNoteASCII()

   442 {

   443     return note.getNoteASCII();

   444 }

   446 QString TreeItem::getNoteOpenDoc()

   447 {

   448     return note.getNoteOpenDoc();

   449 }

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

   452 {

   453 	standardFlags.activate (name);

   454 	model->emitDataHasChanged(this);

   455 }

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

   458 {

   459 	standardFlags.deactivate (name);

   460 	model->emitDataHasChanged(this);

   461 }

   463 void TreeItem::deactivateAllStandardFlags ()

   464 {

   465 	standardFlags.deactivateAll ();

   466 	model->emitDataHasChanged(this);

   467 }

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

   470 {

   471 	standardFlags.toggle (name,master);

   472 	model->emitDataHasChanged(this);

   473 }

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

   476 {

   477 	return standardFlags.isActive (name);

   478 }

   480 QStringList TreeItem::activeStandardFlagNames ()

   481 {

   482 	return standardFlags.activeFlagNames();

   483 }

   485 FlagRow* TreeItem::getStandardFlagRow()

   486 {

   487 	return &standardFlags;

   488 }

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

   491 {

   492 	standardFlags.updateToolBar();

   493 }

   494 */

   495 QStringList TreeItem::activeSystemFlagNames ()

   496 {

   497 	return systemFlags.activeFlagNames();

   498 }

   500 bool TreeItem::canMoveDown()

   501 {

   502 	switch (type)

   503 	{

   504 		case Undefined: return false;

   505 		case MapCenter:

   506 		case Branch:

   507 			if (!parentItem) return false;

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

   509 				return true;

   510 			else

   511 				return false;

   512 			break;

   513 		case Image: return false;

   514 		default: return false;

   515 	}

   516 }

   518 bool TreeItem::canMoveUp()

   519 {

   520 	switch (type)

   521 	{

   522 		case Undefined: return false;

   523 		case MapCenter:

   524 		case Branch:

   525 			if (!parentItem) return false;

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

   527 				return true;

   528 			else

   529 				return false;

   530 			break;

   531 		case Image: return false;

   532 		default: return false;

   533 	}

   534 }

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

   537 {

   538 	objID=s;

   539 }

   541 QString TreeItem::getID()

   542 {

   543 	return objID;

   544 }

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

   548 {

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

   550 		return childItems.at(n);

   551 	else

   552 		return NULL;

   553 }

   555 BranchItem* TreeItem::getFirstBranch()

   556 {

   557 	if (branchCounter>0)

   558 		return getBranchNum (branchOffset);

   559 	else

   560 		return NULL;

   561 }

   563 BranchItem* TreeItem::getLastBranch()

   564 {

   565 	if (branchCounter>0)

   566 		return getBranchNum (branchOffset + branchCounter-1);

   567 	else

   568 		return NULL;

   569 }

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

   572 {

   573 	if (!currentBranch) return NULL;

   574 	int n=num (currentBranch)+1;

   575 	if (n<branchCounter)

   576 		return getBranchNum (branchOffset + n);

   577 	else

   578 		return NULL;

   579 }

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

   583 {

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

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

   586 	else

   587 		return NULL;

   588 }

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

   591 {

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

   593 	{

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

   595 	} else

   596 		return NULL;

   597 }

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

   600 {

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

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

   603 	else

   604 		return NULL;

   605 }

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

   608 {

   609 	if (imageCounter>0 )

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

   611 	else

   612 		return NULL;

   613 }

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

   617 {

   618 	if (isBranchLikeType() )

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

   620 		/*

   621 	if (type==Image)

   622 		//updateVisibility();

   623 	*/

   625 /*

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

   628 		{

   629 			// Hide stuff according to hideExport flag and parents

   630 			//setVisibility (false);

   631 			updateVisibility();

   632 			//FIXME-2 hidden=true;

   633 		}else

   634 		{

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

   638 			XXXXXXXX treeItem should be THIS

   640 			move visible to TreeItem???

   642 			BranchObj now has updateContents

   644 			maybe also start "bool TreeItem::branchlikeType"

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

   649 				setVisibility (false);

   650 			else

   651 				setVisibility (true);

   652 			//FIXME-2 hidden=false;

   653 		}

   655 */

   656 		// And take care of my children

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

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

   659 }

   661 bool TreeItem::hasHiddenExportParent()

   662 {

   663 	// Calls parents recursivly to

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

   666 	if (hidden || hideExport) return true;

   668 	if (parentItem)

   669 		return parentItem->hasHiddenExportParent();

   670 	else

   671 		return false;

   672 }

   675 void TreeItem::setHideInExport(bool b)

   676 {

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

   678 	{

   679 		hideExport=b;

   680 		if (b)

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

   682 		else

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

   684 	}

   685 }

   687 bool TreeItem::hideInExport()

   688 {

   689 	return hideExport;

   690 }

   692 bool TreeItem::isHidden()

   693 {

   694 	return hidden;

   695 }

   697 QString TreeItem::getGeneralAttr()

   698 {

   699 	QString s;

   700 	if (hideExport)

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

   702 	if (!url.isEmpty())

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

   704 	if (!vymLink.isEmpty())

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

   706 	return s;

   707 }

author	insilmaril
	Sat, 08 Aug 2009 21:58:26 +0000
changeset 787	c6bb4fdcc55f
parent 786	6269016c9905
child 788	78ba80b54bc4
permissions	-rw-r--r--