Mercurialvym / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
treeitem.cpp
author insilmaril
Fri, 06 Mar 2009 15:02:58 +0000
changeset 741 1b4d1ea6ea8c
parent 740 6dc0a20031f7
child 745 2d4cc445a86a
permissions -rw-r--r--
Iteration over map works now (again) 
     1 #include <QStringList>

     2 

     3 #include "branchobj.h"

     4 #include "treeitem.h"

     5 

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

     7 {

     8     parentItem = parent;

     9     itemData = data;

    10 	lmo=NULL;

    11 

    12 	branchOffset=0;

    13 	branchCounter=0;

    14 	lastSelectedBranchNum=-1;

    15 }

    16 

    17 TreeItem::~TreeItem()

    18 {

    19     qDeleteAll(childItems);

    20 }

    21 

    22 

    23 void TreeItem::appendChild(TreeItem *item)

    24 {

    25     childItems.append(item);

    26 	

    27 

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

    29 	{

    30 		if (branchCounter==0)

    31 			branchOffset=childItems.count()-1;

    32 		branchCounter++;

    33 	}

    34 }

    35 

    36 void TreeItem::removeChild(int row)

    37 {

    38     if (row>=0)

    39 	{

    40 		delete (childItems.at(row) );

    41 		childItems.removeAt (row);

    42 	} else

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

    44 }

    45 

    46 TreeItem *TreeItem::child(int row)

    47 {

    48     return childItems.value(row);

    49 }

    50 

    51 int TreeItem::childCount() const

    52 {

    53     return childItems.count();

    54 }

    55 

    56 int TreeItem::columnCount() const

    57 {

    58     return itemData.count();

    59 }

    60 

    61 int TreeItem::branchCount() const

    62 {

    63     return branchCounter;

    64 }

    65 int TreeItem::row() const

    66 {

    67     if (parentItem)

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

    69 

    70     return 0;

    71 }

    72 

    73 int TreeItem::column() const

    74 {

    75     return 0;

    76 }

    77 

    78 int TreeItem::depth() 

    79 {

    80 	int d=-1;

    81 	TreeItem *ti=this;

    82 	while (ti!=NULL)

    83 	{

    84 		ti=ti->parent();

    85 		d++;

    86 	}

    87 	return d;

    88 }

    89 

    90 TreeItem *TreeItem::parent()

    91 {

    92     return parentItem;

    93 }

    94 

    95 int TreeItem::num()

    96 {

    97 	switch (type)

    98 	{

    99 		case Undefined: return -1;

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

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

   102 		case Image: return -1; // FIXME

   103 		default: return -1;

   104 	}

   105 	

   106 }

   107 

   108 QVariant TreeItem::data(int column) const

   109 {

   110     return itemData.value(column);

   111 }

   112 

   113 void TreeItem::setHeading (const QString s)

   114 {

   115 	itemData[0]=s;

   116 }

   117 

   118 QString TreeItem::getHeading ()

   119 {

   120 	return itemData[0].toString();

   121 }

   122 

   123 void TreeItem::setNote(const QString s)

   124 {

   125 	switch (type)

   126 	{

   127 		case MapCenter: 

   128 			((BranchObj*)lmo)->setNote(s);

   129 			break;

   130 		case Branch: 

   131 			((BranchObj*)lmo)->setNote(s);

   132 			break;

   133 		default: ;

   134 	}

   135 }

   136 

   137 QString TreeItem::getNote()

   138 {

   139 	switch (type)

   140 	{

   141 		case MapCenter: return ((BranchObj*)lmo)->getNote();

   142 		case Branch: return ((BranchObj*)lmo)->getNote();

   143 		default: return QString ();

   144 	}

   145 }

   146 

   147 void TreeItem::setType(const Type t)

   148 {

   149 	type=t;

   150 	itemData[1]=getTypeName();

   151 }

   152 

   153 TreeItem::Type TreeItem::getType()

   154 {

   155 	return type;

   156 }

   157 

   158 QString TreeItem::getTypeName()

   159 {

   160 	switch (type)

   161 	{

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

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

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

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

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

   167 	}

   168 }

   169 

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

   171 {

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

   173 		return childItems.at(n);

   174 	else

   175 		return NULL;

   176 }

   177 

   178 TreeItem* TreeItem::getFirstBranch()

   179 {

   180 	if (branchCounter>0)

   181 		return getBranchNum (branchOffset);

   182 	else

   183 		return NULL;

   184 }

   185 

   186 TreeItem* TreeItem::getLastBranch()

   187 {

   188 	if (branchCounter>0)

   189 		return getBranchNum (branchOffset + branchCounter-1);

   190 	else

   191 		return NULL;

   192 }

   193 

   194 

   195 TreeItem* TreeItem::getBranchNum(const int &n)

   196 {

   197 	if (branchCounter>0)

   198 		return getChildNum (branchOffset + n);

   199 	else

   200 		return NULL;

   201 }

   202 

   203 void TreeItem::setLastSelectedBranch()

   204 {

   205 	if (parentItem)

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

   207 }

   208 

   209 TreeItem* TreeItem::getLastSelectedBranch()

   210 {

   211 	return getBranchNum (lastSelectedBranchNum);

   212 }

   213 

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

   215 {

   216 	return lmo;

   217 }

   218 

   219 void TreeItem::setLMO(LinkableMapObj *l)

   220 {

   221 	lmo=l;

   222 }

   223
vym