Mercurialvym / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
treeitem.cpp
author insilmaril
Thu, 23 Apr 2009 12:15:31 +0000
changeset 755 ed5b407975b3
parent 754 db0ec4bcf416
child 756 a8a5c7288f57
permissions -rw-r--r--
more data in Tree, less in Map 
     1 #include <iostream>

     2 using namespace std;

     3 

     4 #include <QStringList>

     5 

     6 #include "treeitem.h"

     7 

     8 #include "branchobj.h"

     9 #include "branchitem.h"

    10 #include "vymmodel.h"

    11 

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

    13 {

    14 	model=NULL;

    15 

    16     parentItem = parent;

    17     itemData = data;

    18 	lmo=NULL;

    19 

    20 	branchOffset=0;

    21 	branchCounter=0;

    22 	lastSelectedBranchNum=-1;

    23 

    24 	note.setNote(""); 

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

    26 	// isNoteInEditor=false;

    27 

    28 	hidden=false;

    29 

    30 	// Reset ID

    31 	objID="";

    32 

    33 

    34 }

    35 

    36 TreeItem::~TreeItem()

    37 {

    38 	cout << "Destructor TreeItem\n";

    39 	//if (lmo) delete (lmo);

    40     qDeleteAll(childItems);

    41 }

    42 

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

    44 {

    45 	cout << "TreeItem::saveToDir called directly for ("<<getHeadingStd()<<"), instead of inherited type...\n";	//FIXME-1 triggered on save

    46 	return QString();

    47 }

    48 

    49 

    50 /*

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

    52 

    53 {

    54 	note.copy (other->note);

    55 	model=other->model;

    56 	hideExport=officially 

    57 	other->hideExport;

    58 }

    59 */

    60 

    61 void TreeItem::setModel (VymModel *m)

    62 {

    63 	model=m;

    64 }

    65 

    66 VymModel* TreeItem::getModel ()

    67 {

    68 	return model;

    69 }

    70 

    71 void TreeItem::appendChild(TreeItem *item)

    72 {

    73     childItems.append(item);

    74 	item->setModel (model);

    75 

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

    77 	{

    78 		if (branchCounter==0)

    79 			branchOffset=childItems.count()-1;

    80 		branchCounter++;

    81 	}

    82 }

    83 

    84 void TreeItem::removeChild(int row)

    85 {

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

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

    88 	else

    89 	{

    90 		cout << "TI::removeChild this="<<this<<"  row="<<row<<endl;

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

    92 			branchCounter--;

    93 		childItems.removeAt (row);

    94 	}

    95 }

    96 

    97 TreeItem *TreeItem::child(int row)

    98 {

    99     return childItems.value(row);

   100 }

   101 

   102 int TreeItem::childCount() const

   103 {

   104     return childItems.count();

   105 }

   106 

   107 int TreeItem::childNumber() const

   108 {

   109     if (parentItem)

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

   111 

   112     return 0;

   113 }

   114 

   115 int TreeItem::columnCount() const

   116 {

   117     return itemData.count();

   118 }

   119 

   120 int TreeItem::branchCount() const

   121 {

   122     return branchCounter;

   123 }

   124 

   125 int TreeItem::imageCount() const

   126 {

   127 	int imageCounter=0;

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

   129 }

   130 

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

   132 {

   133 	int xlinkCounter=0;

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

   135 }

   136 

   137 int TreeItem::row() const

   138 {

   139     if (parentItem)

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

   141 

   142     return 0;

   143 }

   144 

   145 int TreeItem::column() const

   146 {

   147     return 0;

   148 }

   149 

   150 int TreeItem::depth() 

   151 {

   152 	int d=-2;

   153 	TreeItem *ti=this;

   154 	while (ti!=NULL)

   155 	{

   156 		ti=ti->parent();

   157 		d++;

   158 	}

   159 	return d;

   160 }

   161 

   162 TreeItem *TreeItem::parent()

   163 {

   164     return parentItem;

   165 }

   166 

   167 int TreeItem::childNum()

   168 {

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

   170 }

   171 

   172 int TreeItem::num()

   173 {

   174 	switch (type)

   175 	{

   176 		case Undefined: return -1;

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

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

   179 		case Image: return -1; // FIXME-2

   180 		default: return -1;

   181 	}

   182 }

   183 

   184 int TreeItem::num (TreeItem *item)

   185 {

   186 	if (!item) return -1;

   187 	switch (item->getType())

   188 	{

   189 		case Undefined: return -1;

   190 		case MapCenter: return childItems.indexOf (this) - branchOffset;

   191 		case Branch: return childItems.indexOf (this) - branchOffset;

   192 		case Image: return -1; // FIXME-2

   193 		default: return -1;

   194 	}

   195 }

   196 

   197 QVariant TreeItem::data(int column) const

   198 {

   199     return itemData.value(column);

   200 }

   201 

   202 void TreeItem::setHeading (const QString s)

   203 {

   204 	itemData[0]=s;

   205 }

   206 

   207 QString TreeItem::getHeading () const

   208 {

   209 	return itemData[0].toString();

   210 }

   211 

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

   213 {

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

   215 }

   216 

   217 void TreeItem::setNote(const QString s)

   218 {

   219 	note.setNote(s);

   220 	// updateNoteFlag();  FIXME-2 needed?

   221 	if (model) 

   222 		model->emitNoteHasChanged (this);

   223 }

   224 

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

   226 {

   227 	note=n;

   228 	// updateNoteFlag();  FIXME-2 needed?

   229 	if (model && updateNoteEditor)	

   230 		model->emitNoteHasChanged (this);

   231 }

   232 

   233 QString TreeItem::getNote()

   234 {

   235 	return note.getNote();

   236 }

   237 

   238 NoteObj TreeItem::getNoteObj()

   239 {

   240 	return note;

   241 }

   242 

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

   244 {

   245     return note.getNoteASCII(indent,width);

   246 }

   247 

   248 QString TreeItem::getNoteASCII()

   249 {

   250     return note.getNoteASCII();

   251 }

   252 

   253 QString TreeItem::getNoteOpenDoc()

   254 {

   255     return note.getNoteOpenDoc();

   256 }

   257 

   258 void TreeItem::setType(const Type t)

   259 {

   260 	type=t;

   261 	itemData[1]=getTypeName();

   262 }

   263 

   264 TreeItem::Type TreeItem::getType()

   265 {

   266 	return type;

   267 }

   268 

   269 bool TreeItem::isBranchLikeType() const

   270 {

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

   272 	return false;

   273 }

   274 

   275 QString TreeItem::getTypeName()

   276 {

   277 	switch (type)

   278 	{

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

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

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

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

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

   284 	}

   285 }

   286 

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

   288 {

   289 	objID=s;

   290 }

   291 

   292 QString TreeItem::getID()

   293 {

   294 	return objID;

   295 }

   296 

   297 

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

   299 {

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

   301 		return childItems.at(n);

   302 	else

   303 		return NULL;

   304 }

   305 

   306 BranchItem* TreeItem::getFirstBranch()

   307 {

   308 	if (branchCounter>0)

   309 		return getBranchNum (branchOffset);

   310 	else

   311 		return NULL;

   312 }

   313 

   314 BranchItem* TreeItem::getLastBranch()

   315 {

   316 	if (branchCounter>0)

   317 		return getBranchNum (branchOffset + branchCounter-1);

   318 	else

   319 		return NULL;

   320 }

   321 

   322 

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

   324 {

   325 	if (branchCounter>0)

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

   327 	else

   328 		return NULL;

   329 }

   330 

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

   332 {

   333 	if (branchCounter>0)

   334 	{

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

   336 	} else

   337 		return NULL;

   338 }

   339 

   340 void TreeItem::setLastSelectedBranch()

   341 {

   342 	if (parentItem)

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

   344 }

   345 

   346 TreeItem* TreeItem::findBySelectString (const QString &s)  //FIXME-1

   347 {

   348 /*

   349 	LinkableMapObj *lmo=this;

   350 	QString part;

   351 	QString typ;

   352 	QString num;

   353 	while (!s.isEmpty() )

   354 	{

   355 		part=s.section(",",0,0);

   356 		typ=part.left (3);

   357 		num=part.right(part.length() - 3);

   358 		if (typ=="mc:")

   359 		{

   360 			if (depth>0)

   361 				return false;	// in a subtree there is no center

   362 			else

   363 				break;

   364 		} else

   365 			if (typ=="bo:")

   366 				lmo=lmo->getTreeItem()->getBranchObjNum (num.toInt());

   367 			else

   368 				if (typ=="fi:")

   369 					lmo=((BranchObj*)lmo)->getFloatImageNum (num.toUInt());

   370 		if (!lmo) break;

   371 		

   372 		if (s.contains(","))

   373 			s=s.right(s.length() - part.length() -1 );

   374 		else	

   375 			break;

   376 	}

   377 	*/

   378 	return NULL;

   379 }

   380 

   381 void TreeItem::setLastSelectedBranch(int i)

   382 {

   383 		lastSelectedBranchNum=i;

   384 }

   385 

   386 TreeItem* TreeItem::getLastSelectedBranch()

   387 {

   388 	return getBranchNum (lastSelectedBranchNum);

   389 }

   390 

   391 

   392 void TreeItem::setHideTmp (HideTmpMode mode)

   393 {

   394 	if (isBranchLikeType() )

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

   396 		/*

   397 	if (type==Image)

   398 		//updateVisibility();

   399 	*/

   400 

   401 /*

   402 

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

   404 		{

   405 			// Hide stuff according to hideExport flag and parents

   406 			//setVisibility (false);

   407 			updateVisibility();

   408 			//FIXME-2 hidden=true;

   409 		}else

   410 		{

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

   412 			

   413 

   414 			XXXXXXXX treeItem should be THIS

   415 

   416 			move visible to TreeItem???

   417 

   418 			BranchObj now has updateContents

   419 

   420 			maybe also start "bool TreeItem::branchlikeType"

   421 

   422 

   423 

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

   425 				setVisibility (false);

   426 			else

   427 				setVisibility (true);

   428 			//FIXME-2 hidden=false;

   429 		}	

   430 

   431 */

   432 		// And take care of my children

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

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

   435 }

   436 

   437 bool TreeItem::hasHiddenExportParent()

   438 {

   439 	// Calls parents recursivly to

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

   441 

   442 	if (hidden || hideExport) return true;

   443 

   444 	if (parentItem) 

   445 		return parentItem->hasHiddenExportParent();

   446 	else

   447 		return false;

   448 }

   449 

   450 

   451 void TreeItem::setHideInExport(bool b) 

   452 {

   453 	if (isBranchLikeType() )

   454 	{

   455 		hideExport=b;

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

   457 		if (b)

   458 			systemFlags->activate("hideInExport");

   459 		else	

   460 			systemFlags->deactivate("hideInExport");

   461 		calcBBoxSize();

   462 		positionBBox();

   463 		requestReposition();	

   464 		*/

   465 	}

   466 }	

   467 

   468 bool TreeItem::hideInExport()

   469 {

   470 	return hideExport;

   471 }	

   472 

   473 bool TreeItem::isHidden()

   474 {

   475 	return hidden;

   476 }	

   477 

   478 

   479 LinkableMapObj* TreeItem::getLMO()	// FIXME-3  VM should be unnecessary in the end

   480 {

   481 	return lmo;

   482 }

   483 

   484 void TreeItem::setLMO(LinkableMapObj *l)

   485 {

   486 	lmo=l;

   487 }

   488
vym