Mercurialvym / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
treeitem.cpp
author insilmaril
Mon, 08 Jun 2009 11:36:56 +0000
changeset 776 25e634a7e1dc
parent 773 340bc29da9a0
child 777 8acac4fade1b
permissions -rw-r--r--
Images basically work (again) 
     1 #include <iostream>

     2 #include <QStringList>

     3 

     4 #include "treeitem.h"

     5 

     6 #include "branchobj.h"

     7 #include "branchitem.h"

     8 #include "vymmodel.h"

     9 

    10 using namespace std;

    11 

    12 extern FlagRow* standardFlagsMaster;

    13 

    14 TreeItem::TreeItem()

    15 {

    16 	init();

    17 	itemData.clear();

    18 	rootItem=this;

    19 	parentItem=NULL;

    20 }

    21 

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

    23 {

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

    25 	init();

    26     parentItem = parent;

    27     itemData = data;

    28 	

    29 	rootItem=this;

    30 	if (parentItem )

    31 		rootItem=parentItem->rootItem;

    32 }

    33 

    34 TreeItem::~TreeItem()

    35 {

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

    37 	TreeItem *ti;

    38 	while (!childItems.isEmpty())

    39 	{

    40 		ti=childItems.takeFirst();

    41 		switch (ti->getType() )

    42 		{

    43 			case TreeItem::MapCenter:

    44 				delete (BranchItem*)ti;

    45 				break;

    46 			case TreeItem::Branch:

    47 				delete (BranchItem*)ti;

    48 				break;

    49 			default:

    50 				delete ti;

    51 				break;

    52 		}

    53 	}	

    54 }

    55 

    56 

    57 void TreeItem::init()

    58 {

    59 	model=NULL;

    60 

    61     parentItem = NULL;

    62     itemData.clear();

    63 

    64 	branchOffset=0;

    65 	branchCounter=0;

    66 	lastSelectedBranchNum=-1;

    67 

    68 	imageOffset=0;

    69 	imageCounter=0;

    70 

    71 	note.setNote(""); 

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

    73 	// isNoteInEditor=false;

    74 

    75 	hidden=false;

    76 	hideExport=false;

    77 

    78 	// Reset ID

    79 	objID="";

    80 

    81 	standardFlags.setMasterRow (standardFlagsMaster);

    82 }

    83 

    84 

    85 /*

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

    87 

    88 {

    89 	note.copy (other->note);

    90 	model=other->model;

    91 	hideExport=officially 

    92 	other->hideExport;

    93 }

    94 */

    95 

    96 void TreeItem::setModel (VymModel *m)

    97 {

    98 	model=m;

    99 }

   100 

   101 VymModel* TreeItem::getModel ()

   102 {

   103 	return model;

   104 }

   105 

   106 int TreeItem::getRowNumAppend (TreeItem *item)

   107 {	

   108 	switch (item->type)

   109 	{

   110 		case MapCenter: return branchOffset + branchCounter;

   111 		case Branch: return branchOffset + branchCounter;

   112 		case Image: return imageOffset + imageCounter;

   113 		default: return -1;

   114 	}

   115 }

   116 

   117 void TreeItem::appendChild(TreeItem *item)

   118 {

   119 	item->parentItem=this;

   120 	item->rootItem=rootItem;

   121 	item->setModel (model);

   122 

   123 	if (item->type == Image)

   124 	{

   125 		childItems.insert (imageCounter,item);

   126 		// images are on top of list

   127 		if (imageCounter==0)

   128 			imageOffset=0;

   129 		imageCounter++;

   130 		branchOffset++;

   131 	}

   132 

   133 	if (item->isBranchLikeType())

   134 	{

   135 		// branches are on bottom of list

   136 		childItems.append(item);

   137 		if (branchCounter==0)

   138 			branchOffset=childItems.count()-1;

   139 		branchCounter++;

   140 	}

   141 }

   142 

   143 void TreeItem::removeChild(int row)

   144 {

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

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

   147 	else

   148 	{

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

   150 			branchCounter--;

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

   152 		{

   153 			imageCounter--;

   154 			if (branchOffset>0) 

   155 				branchOffset--;

   156 		}	

   157 		childItems.removeAt (row);

   158 	}

   159 }

   160 

   161 void TreeItem::removeChildBranches()

   162 {

   163 	while ( childItems.size()>0)

   164 	{

   165 		branchCounter--;

   166 		childItems.removeAt (0);

   167 	}

   168 }

   169 

   170 TreeItem *TreeItem::child(int row)

   171 {

   172     return childItems.value(row);

   173 }

   174 

   175 int TreeItem::childCount() const

   176 {

   177     return childItems.count();

   178 }

   179 

   180 int TreeItem::childNumber() const

   181 {

   182     if (parentItem)

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

   184 

   185     return 0;

   186 }

   187 

   188 int TreeItem::columnCount() const

   189 {

   190     return itemData.count();

   191 }

   192 

   193 int TreeItem::branchCount() const

   194 {

   195     return branchCounter;

   196 }

   197 

   198 int TreeItem::imageCount() const

   199 {

   200     return imageCounter; 

   201 }

   202 

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

   204 {

   205 	int xlinkCounter=0;

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

   207 }

   208 

   209 int TreeItem::row() const

   210 {

   211     if (parentItem)

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

   213 

   214     return 0;

   215 }

   216 

   217 int TreeItem::column() const

   218 {

   219     return 0;

   220 }

   221 

   222 int TreeItem::depth() 

   223 {

   224 	int d=-2;

   225 	TreeItem *ti=this;

   226 	while (ti!=NULL)

   227 	{

   228 		ti=ti->parent();

   229 		d++;

   230 	}

   231 	return d;

   232 }

   233 

   234 TreeItem *TreeItem::parent()

   235 {

   236     return parentItem;

   237 }

   238 

   239 int TreeItem::childNum()

   240 {

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

   242 }

   243 

   244 int TreeItem::num()

   245 {

   246 	switch (type)

   247 	{

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

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

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

   251 		default: return -1;

   252 	}

   253 }

   254 

   255 int TreeItem::num (TreeItem *item)

   256 {

   257 	if (!item) return -1;

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

   259 	switch (item->getType())

   260 	{

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

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

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

   264 		default: return -1;

   265 	}

   266 }

   267 void TreeItem::setType(const Type t)

   268 {

   269 	type=t;

   270 	itemData[1]=getTypeName();

   271 }

   272 

   273 TreeItem::Type TreeItem::getType()

   274 {

   275 	return type;

   276 }

   277 

   278 bool TreeItem::isBranchLikeType() const

   279 {

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

   281 	return false;

   282 }

   283 

   284 QString TreeItem::getTypeName()

   285 {

   286 	switch (type)

   287 	{

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

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

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

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

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

   293 	}

   294 }

   295 

   296 

   297 QVariant TreeItem::data(int column) const

   298 {

   299     return itemData.value(column);

   300 }

   301 

   302 void TreeItem::setHeading (const QString s)

   303 {

   304 	itemData[0]=s;

   305 }

   306 

   307 QString TreeItem::getHeading () const

   308 {

   309 	return itemData[0].toString();

   310 }

   311 

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

   313 {

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

   315 }

   316 

   317 void TreeItem::setHeadingColor (QColor color)

   318 {

   319 	headingColor=color;

   320 }

   321 

   322 QColor TreeItem::getHeadingColor ()

   323 {

   324 	return headingColor;

   325 }

   326 

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

   328 {

   329 	url=u;

   330 	if (!url.isEmpty())

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

   332 	else

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

   334 }

   335 

   336 QString TreeItem::getURL ()

   337 {

   338 	return url;

   339 }

   340 

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

   342 {

   343 	if (!vl.isEmpty())

   344 	{

   345 		// We need the relative (from loading) 

   346 		// or absolute path (from User event)

   347 		// and build the absolute path.

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

   349 		// current map to build absolute path

   350 		QDir d(vl);

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

   352 		{

   353 			QString p=model->getDestPath();

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

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

   356 			d.convertToAbs();

   357 		}

   358 		vymLink=d.path();

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

   360 	}	

   361 	else	

   362 	{

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

   364 		vymLink.clear();

   365 	}	

   366 }

   367 

   368 QString TreeItem::getVymLink ()

   369 {

   370 	return vymLink;

   371 }

   372 

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

   374 {

   375 	NoteObj n;

   376 	n.setNote(s);

   377 	setNoteObj (n,false);

   378 }

   379 

   380 void TreeItem::clearNote()

   381 {

   382 	note.clear();

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

   384 }

   385 

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

   387 	note=n;

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

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

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

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

   392 }

   393 

   394 QString TreeItem::getNote()

   395 {

   396 	return note.getNote();

   397 }

   398 

   399 bool TreeItem::hasEmptyNote()

   400 {

   401 	return note.isEmpty();

   402 }

   403 

   404 NoteObj TreeItem::getNoteObj()

   405 {

   406 	return note;

   407 }

   408 

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

   410 {

   411     return note.getNoteASCII(indent,width);

   412 }

   413 

   414 QString TreeItem::getNoteASCII()

   415 {

   416     return note.getNoteASCII();

   417 }

   418 

   419 QString TreeItem::getNoteOpenDoc()

   420 {

   421     return note.getNoteOpenDoc();

   422 }

   423 

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

   425 {

   426 	standardFlags.activate (name);

   427 	model->emitDataHasChanged(this);

   428 }

   429 

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

   431 {

   432 	standardFlags.deactivate (name);

   433 	model->emitDataHasChanged(this);

   434 }

   435 

   436 void TreeItem::deactivateAllStandardFlags ()

   437 {

   438 	standardFlags.deactivateAll ();

   439 	model->emitDataHasChanged(this);

   440 }

   441 

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

   443 {

   444 	standardFlags.toggle (name,master);

   445 	model->emitDataHasChanged(this);

   446 }

   447 

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

   449 {

   450 	return standardFlags.isActive (name);

   451 }

   452 

   453 QStringList TreeItem::activeStandardFlagNames ()

   454 {

   455 	return standardFlags.activeFlagNames();

   456 }

   457 

   458 FlagRow* TreeItem::getStandardFlagRow()

   459 {

   460 	return &standardFlags;

   461 }

   462 

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

   464 {

   465 	standardFlags.updateToolBar();

   466 }

   467 */

   468 QStringList TreeItem::activeSystemFlagNames ()

   469 {

   470 	return systemFlags.activeFlagNames();

   471 }

   472 

   473 bool TreeItem::canMoveDown()

   474 {

   475 	switch (type)

   476 	{

   477 		case Undefined: return false;

   478 		case MapCenter: 

   479 		case Branch: 

   480 			if (!parentItem) return false;

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

   482 				return true;

   483 			else

   484 				return false;

   485 			break;	

   486 		case Image: return false;

   487 		default: return false;

   488 	}

   489 }

   490 

   491 bool TreeItem::canMoveUp()

   492 {

   493 	switch (type)

   494 	{

   495 		case Undefined: return false;

   496 		case MapCenter: 

   497 		case Branch: 

   498 			if (!parentItem) return false;

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

   500 				return true;

   501 			else

   502 				return false;

   503 			break;	

   504 		case Image: return false;

   505 		default: return false;

   506 	}

   507 }

   508 

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

   510 {

   511 	objID=s;

   512 }

   513 

   514 QString TreeItem::getID()

   515 {

   516 	return objID;

   517 }

   518 

   519 

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

   521 {

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

   523 		return childItems.at(n);

   524 	else

   525 		return NULL;

   526 }

   527 

   528 BranchItem* TreeItem::getFirstBranch()

   529 {

   530 	if (branchCounter>0)

   531 		return getBranchNum (branchOffset);

   532 	else

   533 		return NULL;

   534 }

   535 

   536 BranchItem* TreeItem::getLastBranch()

   537 {

   538 	if (branchCounter>0)

   539 		return getBranchNum (branchOffset + branchCounter-1);

   540 	else

   541 		return NULL;

   542 }

   543 

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

   545 {

   546 	if (!currentBranch) return NULL;

   547 	int n=num (currentBranch)+1;

   548 	if (n<branchCounter)

   549 		return getBranchNum (branchOffset + n);

   550 	else

   551 		return NULL;

   552 }

   553 

   554 

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

   556 {

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

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

   559 	else

   560 		return NULL;

   561 }

   562 

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

   564 {

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

   566 	{

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

   568 	} else

   569 		return NULL;

   570 }

   571 

   572 void TreeItem::setLastSelectedBranch()

   573 {

   574 	if (parentItem)

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

   576 }

   577 

   578 void TreeItem::setLastSelectedBranch(int i)

   579 {

   580 		lastSelectedBranchNum=i;

   581 }

   582 

   583 TreeItem* TreeItem::getLastSelectedBranch()

   584 {

   585 	return getBranchNum (lastSelectedBranchNum);

   586 }

   587 

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

   589 {

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

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

   592 	else

   593 		return NULL;

   594 }

   595 

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

   597 {

   598 	if (imageCounter>0 )

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

   600 	else

   601 		return NULL;

   602 }

   603 

   604 void TreeItem::setHideTmp (HideTmpMode mode)

   605 {

   606 	if (isBranchLikeType() )

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

   608 		/*

   609 	if (type==Image)

   610 		//updateVisibility();

   611 	*/

   612 

   613 /*

   614 

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

   616 		{

   617 			// Hide stuff according to hideExport flag and parents

   618 			//setVisibility (false);

   619 			updateVisibility();

   620 			//FIXME-2 hidden=true;

   621 		}else

   622 		{

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

   624 			

   625 

   626 			XXXXXXXX treeItem should be THIS

   627 

   628 			move visible to TreeItem???

   629 

   630 			BranchObj now has updateContents

   631 

   632 			maybe also start "bool TreeItem::branchlikeType"

   633 

   634 

   635 

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

   637 				setVisibility (false);

   638 			else

   639 				setVisibility (true);

   640 			//FIXME-2 hidden=false;

   641 		}	

   642 

   643 */

   644 		// And take care of my children

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

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

   647 }

   648 

   649 bool TreeItem::hasHiddenExportParent()

   650 {

   651 	// Calls parents recursivly to

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

   653 

   654 	if (hidden || hideExport) return true;

   655 

   656 	if (parentItem) 

   657 		return parentItem->hasHiddenExportParent();

   658 	else

   659 		return false;

   660 }

   661 

   662 

   663 void TreeItem::setHideInExport(bool b) 

   664 {

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

   666 	{

   667 		hideExport=b;

   668 		// FIXME-1 call setVis and updateContentsSize...

   669 		if (b)

   670 			systemFlags.activate("hideInExport");

   671 		else	

   672 			systemFlags.deactivate("hideInExport");

   673 	}

   674 }	

   675 

   676 bool TreeItem::hideInExport()

   677 {

   678 	return hideExport;

   679 }	

   680 

   681 bool TreeItem::isHidden()

   682 {

   683 	return hidden;

   684 }	

   685 

   686 

   687
vym