Mercurialvym / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
treeitem.cpp
author insilmaril
Wed, 20 May 2009 15:40:14 +0000
changeset 772 e3f722759c7e
parent 771 01f2f6d6789d
child 773 340bc29da9a0
permissions -rw-r--r--
Fixed segfault when closing a map 
     1 #include <iostream>

     2 #include <QStringList>

     3 

     4 #include "treeitem.h"

     5 

     6 #include "branchobj.h"

     7 #include "branchitem.h"

     8 #include "mapcenteritem.h"

     9 #include "vymmodel.h"

    10 

    11 using namespace std;

    12 

    13 extern FlagRow* standardFlagsMaster;

    14 

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

    16 {

    17 	//cout << "Constructor TreeItem "<<endl;

    18 	init();

    19     parentItem = parent;

    20     itemData = data;

    21 }

    22 

    23 TreeItem::~TreeItem()

    24 {

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

    26 	TreeItem *ti;

    27 	while (!childItems.isEmpty())

    28 	{

    29 		ti=childItems.takeFirst();

    30 		switch (ti->getType() )

    31 		{

    32 			case TreeItem::MapCenter:

    33 				delete (MapCenterItem*)ti;

    34 				break;

    35 			case TreeItem::Branch:

    36 				delete (BranchItem*)ti;

    37 				break;

    38 			default:

    39 				delete ti;

    40 				break;

    41 		}

    42 	}	

    43 }

    44 

    45 

    46 void TreeItem::init()

    47 {

    48 	model=NULL;

    49 

    50     parentItem = NULL;

    51     itemData.clear();

    52 

    53 	branchOffset=0;

    54 	branchCounter=0;

    55 	lastSelectedBranchNum=-1;

    56 

    57 	imageOffset=0;

    58 	imageCounter=0;

    59 

    60 	note.setNote(""); 

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

    62 	// isNoteInEditor=false;

    63 

    64 	hidden=false;

    65 

    66 	// Reset ID

    67 	objID="";

    68 

    69 	standardFlags.setMasterRow (standardFlagsMaster);

    70 }

    71 

    72 QString TreeItem::saveToDir (const QString &tmpdir,const QString &prefix, const QPointF& offset)

    73 {

    74 	cout<< "TreeItem::saveToDir called directly for ("<<getHeadingStd()<<"), instead of inherited type...\n";

    75 	return QString();

    76 }

    77 

    78 

    79 /*

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

    81 

    82 {

    83 	note.copy (other->note);

    84 	model=other->model;

    85 	hideExport=officially 

    86 	other->hideExport;

    87 }

    88 */

    89 

    90 void TreeItem::setModel (VymModel *m)

    91 {

    92 	model=m;

    93 }

    94 

    95 VymModel* TreeItem::getModel ()

    96 {

    97 	return model;

    98 }

    99 

   100 void TreeItem::appendChild(TreeItem *item)

   101 {

   102     childItems.append(item);

   103 	item->parentItem=this;

   104 	item->setModel (model);

   105 

   106 	if (item->type == Branch || item->type ==MapCenter)

   107 	{

   108 		if (branchCounter==0)

   109 			branchOffset=childItems.count()-1;

   110 		branchCounter++;

   111 	}

   112 }

   113 

   114 void TreeItem::removeChild(int row)

   115 {

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

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

   118 	else

   119 	{

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

   121 			branchCounter--;

   122 		childItems.removeAt (row);

   123 	}

   124 }

   125 

   126 void TreeItem::removeChildBranches()

   127 {

   128 	while ( childItems.size()>0)

   129 	{

   130 		branchCounter--;

   131 		childItems.removeAt (0);

   132 	}

   133 }

   134 

   135 TreeItem *TreeItem::child(int row)

   136 {

   137     return childItems.value(row);

   138 }

   139 

   140 int TreeItem::childCount() const

   141 {

   142     return childItems.count();

   143 }

   144 

   145 int TreeItem::childNumber() const

   146 {

   147     if (parentItem)

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

   149 

   150     return 0;

   151 }

   152 

   153 int TreeItem::columnCount() const

   154 {

   155     return itemData.count();

   156 }

   157 

   158 int TreeItem::branchCount() const

   159 {

   160     return branchCounter;

   161 }

   162 

   163 int TreeItem::imageCount() const

   164 {

   165 	int imageCounter=0;

   166     return imageCounter; // FIXME-1 imageCounter needs to be calculated...

   167 }

   168 

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

   170 {

   171 	int xlinkCounter=0;

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

   173 }

   174 

   175 int TreeItem::row() const

   176 {

   177     if (parentItem)

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

   179 

   180     return 0;

   181 }

   182 

   183 int TreeItem::column() const

   184 {

   185     return 0;

   186 }

   187 

   188 int TreeItem::depth() 

   189 {

   190 	int d=-2;

   191 	TreeItem *ti=this;

   192 	while (ti!=NULL)

   193 	{

   194 		ti=ti->parent();

   195 		d++;

   196 	}

   197 	return d;

   198 }

   199 

   200 TreeItem *TreeItem::parent()

   201 {

   202     return parentItem;

   203 }

   204 

   205 int TreeItem::childNum()

   206 {

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

   208 }

   209 

   210 int TreeItem::num()

   211 {

   212 	switch (type)

   213 	{

   214 		case Undefined: return -1;

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

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

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

   218 		default: return -1;

   219 	}

   220 }

   221 

   222 int TreeItem::num (TreeItem *item)

   223 {

   224 	if (!item) return -1;

   225 	switch (item->getType())

   226 	{

   227 		case Undefined: return -1;

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

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

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

   231 		default: return -1;

   232 	}

   233 }

   234 void TreeItem::setType(const Type t)

   235 {

   236 	type=t;

   237 	itemData[1]=getTypeName();

   238 }

   239 

   240 TreeItem::Type TreeItem::getType()

   241 {

   242 	return type;

   243 }

   244 

   245 bool TreeItem::isBranchLikeType() const

   246 {

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

   248 	return false;

   249 }

   250 

   251 QString TreeItem::getTypeName()

   252 {

   253 	switch (type)

   254 	{

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

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

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

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

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

   260 	}

   261 }

   262 

   263 

   264 QVariant TreeItem::data(int column) const

   265 {

   266     return itemData.value(column);

   267 }

   268 

   269 void TreeItem::setHeading (const QString s)

   270 {

   271 	itemData[0]=s;

   272 }

   273 

   274 QString TreeItem::getHeading () const

   275 {

   276 	return itemData[0].toString();

   277 }

   278 

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

   280 {

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

   282 }

   283 

   284 void TreeItem::setHeadingColor (QColor color)

   285 {

   286 	headingColor=color;

   287 }

   288 

   289 QColor TreeItem::getHeadingColor ()

   290 {

   291 	return headingColor;

   292 }

   293 

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

   295 {

   296 	url=u;

   297 	if (!url.isEmpty())

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

   299 	else

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

   301 }

   302 

   303 QString TreeItem::getURL ()

   304 {

   305 	return url;

   306 }

   307 

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

   309 {

   310 	if (!vl.isEmpty())

   311 	{

   312 		// We need the relative (from loading) 

   313 		// or absolute path (from User event)

   314 		// and build the absolute path.

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

   316 		// current map to build absolute path

   317 		QDir d(vl);

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

   319 		{

   320 			QString p=model->getDestPath();

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

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

   323 			d.convertToAbs();

   324 		}

   325 		vymLink=d.path();

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

   327 	}	

   328 	else	

   329 	{

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

   331 		vymLink.clear();

   332 	}	

   333 }

   334 

   335 QString TreeItem::getVymLink ()

   336 {

   337 	return vymLink;

   338 }

   339 

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

   341 {

   342 	NoteObj n;

   343 	n.setNote(s);

   344 	setNoteObj (n,false);

   345 }

   346 

   347 void TreeItem::clearNote()

   348 {

   349 	note.clear();

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

   351 }

   352 

   353 void TreeItem::setNoteObj(const NoteObj &n, bool updateNoteEditor) //FIXME-1 setNoteObj is called for every select or so???

   354 {

   355 	note=n;

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

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

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

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

   360 }

   361 

   362 QString TreeItem::getNote()

   363 {

   364 	return note.getNote();

   365 }

   366 

   367 bool TreeItem::hasEmptyNote()

   368 {

   369 	return note.isEmpty();

   370 }

   371 

   372 NoteObj TreeItem::getNoteObj()

   373 {

   374 	return note;

   375 }

   376 

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

   378 {

   379     return note.getNoteASCII(indent,width);

   380 }

   381 

   382 QString TreeItem::getNoteASCII()

   383 {

   384     return note.getNoteASCII();

   385 }

   386 

   387 QString TreeItem::getNoteOpenDoc()

   388 {

   389     return note.getNoteOpenDoc();

   390 }

   391 

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

   393 {

   394 	standardFlags.activate (name);

   395 	model->emitDataHasChanged(this);

   396 }

   397 

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

   399 {

   400 	standardFlags.deactivate (name);

   401 	model->emitDataHasChanged(this);

   402 }

   403 

   404 void TreeItem::deactivateAllStandardFlags ()

   405 {

   406 	standardFlags.deactivateAll ();

   407 	model->emitDataHasChanged(this);

   408 }

   409 

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

   411 {

   412 	standardFlags.toggle (name,master);

   413 	model->emitDataHasChanged(this);

   414 }

   415 

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

   417 {

   418 	return standardFlags.isActive (name);

   419 }

   420 

   421 QStringList TreeItem::activeStandardFlagNames ()

   422 {

   423 	return standardFlags.activeFlagNames();

   424 }

   425 

   426 FlagRow* TreeItem::getStandardFlagRow()

   427 {

   428 	return &standardFlags;

   429 }

   430 

   431 /*

   432 void TreeItem::updateToolBar()

   433 {

   434 	standardFlags.updateToolBar();

   435 }

   436 */

   437 QStringList TreeItem::activeSystemFlagNames ()	//FIXME-1 missing: scrolled-tmp,hideInExport

   438 {

   439 	return systemFlags.activeFlagNames();

   440 }

   441 

   442 bool TreeItem::canMoveDown()

   443 {

   444 	switch (type)

   445 	{

   446 		case Undefined: return false;

   447 		case MapCenter: 

   448 		case Branch: 

   449 			if (!parentItem) return false;

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

   451 				return true;

   452 			else

   453 				return false;

   454 			break;	

   455 		case Image: return false;

   456 		default: return false;

   457 	}

   458 }

   459 

   460 bool TreeItem::canMoveUp()

   461 {

   462 	switch (type)

   463 	{

   464 		case Undefined: return false;

   465 		case MapCenter: 

   466 		case Branch: 

   467 			if (!parentItem) return false;

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

   469 				return true;

   470 			else

   471 				return false;

   472 			break;	

   473 		case Image: return false;

   474 		default: return false;

   475 	}

   476 }

   477 

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

   479 {

   480 	objID=s;

   481 }

   482 

   483 QString TreeItem::getID()

   484 {

   485 	return objID;

   486 }

   487 

   488 

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

   490 {

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

   492 		return childItems.at(n);

   493 	else

   494 		return NULL;

   495 }

   496 

   497 BranchItem* TreeItem::getFirstBranch()

   498 {

   499 	if (branchCounter>0)

   500 		return getBranchNum (branchOffset);

   501 	else

   502 		return NULL;

   503 }

   504 

   505 BranchItem* TreeItem::getLastBranch()

   506 {

   507 	if (branchCounter>0)

   508 		return getBranchNum (branchOffset + branchCounter-1);

   509 	else

   510 		return NULL;

   511 }

   512 

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

   514 {

   515 	if (!currentBranch) return NULL;

   516 	int n=num (currentBranch)+1;

   517 	if (n<branchCounter)

   518 		return getBranchNum (branchOffset + n);

   519 	else

   520 		return NULL;

   521 }

   522 

   523 

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

   525 {

   526 	if (branchCounter>0)

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

   528 	else

   529 		return NULL;

   530 }

   531 

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

   533 {

   534 	if (branchCounter>0)

   535 	{

   536 		return (BranchObj*)(getChildNum (branchOffset+n)->lmo);

   537 	} else

   538 		return NULL;

   539 }

   540 

   541 void TreeItem::setLastSelectedBranch()

   542 {

   543 	if (parentItem)

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

   545 }

   546 

   547 void TreeItem::setLastSelectedBranch(int i)

   548 {

   549 		lastSelectedBranchNum=i;

   550 }

   551 

   552 TreeItem* TreeItem::getLastSelectedBranch()

   553 {

   554 	return getBranchNum (lastSelectedBranchNum);

   555 }

   556 

   557 

   558 void TreeItem::setHideTmp (HideTmpMode mode)

   559 {

   560 	if (isBranchLikeType() )

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

   562 		/*

   563 	if (type==Image)

   564 		//updateVisibility();

   565 	*/

   566 

   567 /*

   568 

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

   570 		{

   571 			// Hide stuff according to hideExport flag and parents

   572 			//setVisibility (false);

   573 			updateVisibility();

   574 			//FIXME-2 hidden=true;

   575 		}else

   576 		{

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

   578 			

   579 

   580 			XXXXXXXX treeItem should be THIS

   581 

   582 			move visible to TreeItem???

   583 

   584 			BranchObj now has updateContents

   585 

   586 			maybe also start "bool TreeItem::branchlikeType"

   587 

   588 

   589 

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

   591 				setVisibility (false);

   592 			else

   593 				setVisibility (true);

   594 			//FIXME-2 hidden=false;

   595 		}	

   596 

   597 */

   598 		// And take care of my children

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

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

   601 }

   602 

   603 bool TreeItem::hasHiddenExportParent()

   604 {

   605 	// Calls parents recursivly to

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

   607 

   608 	if (hidden || hideExport) return true;

   609 

   610 	if (parentItem) 

   611 		return parentItem->hasHiddenExportParent();

   612 	else

   613 		return false;

   614 }

   615 

   616 

   617 void TreeItem::setHideInExport(bool b) 

   618 {

   619 	if (isBranchLikeType() )

   620 	{

   621 		hideExport=b;

   622 		/* FIXME-1 call setVis and updateContentsSize...

   623 		if (b)

   624 			systemFlags->activate("hideInExport");

   625 		else	

   626 			systemFlags->deactivate("hideInExport");

   627 		calcBBoxSize();

   628 		positionBBox();

   629 		requestReposition();	

   630 		*/

   631 	}

   632 }	

   633 

   634 bool TreeItem::hideInExport()

   635 {

   636 	return hideExport;

   637 }	

   638 

   639 bool TreeItem::isHidden()

   640 {

   641 	return hidden;

   642 }	

   643 

   644 

   645
vym