FXTreeItem*
GNEFrame::ACHierarchy::addACIntoList(GNEAttributeCarrier *AC, FXTreeItem* itemParent) {
FXTreeItem* item = myTreelist->insertItem(0, itemParent, AC->getHierarchyName().c_str(), AC->getIcon(), AC->getIcon());
myTreeItemToACMap[item] = AC;
item->setExpanded(true);
return item;
}
long GMSourceView::onCmdSourceSelected(FXObject*,FXSelector,void*){
FXTreeItem * item = sourcelist->getCurrentItem();
if (item) {
setSource(static_cast<GMSource*>(item->getData()),false);
}
return 1;
}
void GMSourceView::init() {
loadSettings("window");
clear();
listsources();
FXString key = getApp()->reg().readStringEntry("window","source-list-current","");
if (!key.empty()){
FXTreeItem * item = sourcelist->getFirstItem();
while(item){
GMSource * src = static_cast<GMSource*>(item->getData());
if (src->settingKey()==key) {
sourcelist->setCurrentItem(item);
break;
}
item=item->getBelow();
}
}
if (sourcelist->getCurrentItem()==nullptr && sourcelist->getFirstItem())
sourcelist->setCurrentItem(sourcelist->getFirstItem());
source=static_cast<GMSource*>(sourcelist->getItemData(sourcelist->getCurrentItem()));
GMPlayerManager::instance()->getTrackView()->init(source);
}
void ProjectBrowser::renameDir(FXString project, FXString olddirname, FXString newdirname)
{
FXTreeItem* root = projectTree->findItem(project);
if (!root) return;
FXTreeItem* sub = projectTree->findItem(olddirname, root);
if (!sub) return;
sub->setText(newdirname);
}
void ProjectBrowser::renameFile (FXString project, FXString name, FXString newname, FXString dir)
{
FXTreeItem* root = projectTree->findItem(project);
if (!root) return;
FXTreeItem* sub = projectTree->findItem(dir, root);
if (!sub) return;
FXTreeItem* file = projectTree->findItem(name, sub);
if (!file) return;
file->setText(newname);
}
long GMSourceView::onSourceTipText(FXObject*sender,FXSelector,void*ptr){
FXint x,y; FXuint buttons;
sourcelist->getCursorPosition(x,y,buttons);
FXTreeItem * item = sourcelist->getItemAt(x,y);
if (item && item->getData()) {
GMSource * src = static_cast<GMSource*>(item->getData());
return src->handle(sender,FXSEL(SEL_QUERY_TIP,0),ptr);
}
return 0;
}
void
DirectoryView::change_directory(FXTreeItem* item)
{
iconlist->clearItems();
for(FXTreeItem* it = item->getFirst(); it != NULL; it = it->getNext())
{
DreamfallFileEntry* entry = static_cast<DreamfallFileEntry*>(it->getData());
FXIcon* big;
FXIcon* small;
int size;
const char* typestr = "DIRECTORY";
const char* pak = "";
switch(entry->get_type())
{
case DreamfallFileEntry::DIRECTORY_FILE_ENTRY:
big = Icon::large_folder;
small = Icon::folder_closed;
size = it->getNumChildren();
typestr = "Directory";
break;
case DreamfallFileEntry::PAK_FILE_ENTRY:
big = (entry->get_pak().type == FILETYPE_SHARK3D)?Icon::large_file:Icon::large_shark;
small = Icon::unknown_document;
size = entry->get_pak().filesize;
typestr = filetype2string(entry->get_pak().type);
pak = entry->get_pak().pakfile.c_str();
break;
break;
default:
big = Icon::large_file;
small = Icon::unknown_document;
size = 0; //entry->filesize;
break;
}
iconlist->appendItem(FXString().format("%s\t%s\t%dKB\t%s",
entry->get_label().c_str(),
typestr,
size/1024,
pak),
big, small,
it);
}
iconlist->setSortFunc(iconlist_sorter);
iconlist->sortItems();
}
void GMSourceView::updateSource(GMSource * src){
FXTreeItem * item = sourcelist->getFirstItem();
while(item) {
if (item->getData()==src) {
item->setText(tr(src->getName().text()));
break;
}
item=item->getBelow();
}
resort();
}
FXString ProjectBrowser::getActiveProject()
{
FXTreeItem* current = projectTree->getCurrentItem();
while (true)
{
FXTreeItem* parent = current->getParent();
if (parent == NULL)
break;
current = parent;
}
return current->getText();
}
void GMSourceView::setSource(GMSource * src,FXbool makecurrent/*=true*/){
if (src!=source) {
source=src;
if (makecurrent) {
FXTreeItem * item = sourcelist->getFirstItem();
while(item) {
if (item->getData()==src) {
sourcelist->setCurrentItem(item,false);
break;
}
item=item->getNext();
}
}
GMPlayerManager::instance()->getTrackView()->setSource(source);
}
}
FXString ProjectBrowser::getPathname(FXTreeItem* item)
{
FXString path;
FXTreeItem* current = item;
while (true)
{
path.prepend(current->getText());
path.prepend(FS::dirSeparator());
FXTreeItem* parent = current->getParent();
if (parent == NULL)
break;
current = parent;
}
path.prepend(mainWin->settings->getStringValue("baseDir"));
return path;
}
void
GNEFrame::ACHierarchy::showAttributeCarrierChilds(GNEAttributeCarrier *AC, FXTreeItem* itemParent) {
// Switch gl type of ac
switch (AC->getTag()) {
case SUMO_TAG_JUNCTION: {
// retrieve junction
GNEJunction* junction = myFrameParent->getViewNet()->getNet()->retrieveJunction(AC->getID(), false);
if(junction) {
// insert junction item
FXTreeItem* junctionItem = addACIntoList(AC, itemParent);
// insert edges
for (auto i : junction->getGNEEdges()) {
showAttributeCarrierChilds(i, junctionItem);
}
// insert crossings
for (auto i : junction->getGNECrossings()) {
showAttributeCarrierChilds(i, junctionItem);
}
}
break;
}
case SUMO_TAG_EDGE: {
// retrieve edge
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(AC->getID(), false);
if(edge) {
// insert edge item
FXTreeItem* edgeItem = addACIntoList(AC, itemParent);
// insert lanes
for (int i = 0; i < (int)edge->getLanes().size(); i++) {
showAttributeCarrierChilds(edge->getLanes().at(i), edgeItem);
}
// insert additionals of edge
for (auto i : edge->getAdditionalChilds()) {
showAttributeCarrierChilds(i, edgeItem);
}
}
break;
}
case SUMO_TAG_LANE: {
// retrieve lane
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(AC->getID(), false);
if(lane) {
// insert lane item
FXTreeItem* laneItem = addACIntoList(AC, itemParent);
// insert additionals of lanes
for (auto i : lane->getAdditionalChilds()) {
showAttributeCarrierChilds(i, laneItem);
}
// insert incoming connections of lanes (by default isn't expanded)
if (lane->getGNEIncomingConnections().size() > 0) {
std::vector<GNEConnection*> incomingLaneConnections = lane->getGNEIncomingConnections();
FXTreeItem* incomingConnections = myTreelist->insertItem(0, laneItem, "Incomings", incomingLaneConnections.front()->getIcon(), lane->getGNEIncomingConnections().front()->getIcon());
myTreeItemsConnections.insert(incomingConnections);
incomingConnections->setExpanded(false);
// insert incoming connections
for (auto i : incomingLaneConnections) {
showAttributeCarrierChilds(i, incomingConnections);
}
}
// insert outcoming connections of lanes (by default isn't expanded)
if (lane->getGNEOutcomingConnections().size() > 0) {
std::vector<GNEConnection*> outcomingLaneConnections = lane->getGNEOutcomingConnections();
FXTreeItem* outgoingConnections = myTreelist->insertItem(0, laneItem, "Outcomings", outcomingLaneConnections.front()->getIcon(), lane->getGNEOutcomingConnections().front()->getIcon());
myTreeItemsConnections.insert(outgoingConnections);
outgoingConnections->setExpanded(false);
// insert outcoming connections
for (auto i : outcomingLaneConnections) {
showAttributeCarrierChilds(i, outgoingConnections);
}
}
}
break;
}
case SUMO_TAG_POI:
case SUMO_TAG_POLY:
case SUMO_TAG_CROSSING:
case SUMO_TAG_CONNECTION: {
// insert connection item
addACIntoList(AC, itemParent);
break;
}
default: {
// check if is an additional
if(GNEAttributeCarrier::getTagProperties(AC->getTag()).isAdditional()) {
// retrieve additional
GNEAdditional *additional = myFrameParent->getViewNet()->getNet()->retrieveAdditional(AC->getTag(), AC->getID(), false);
if(additional) {
// insert additional item
FXTreeItem* additionalItem = addACIntoList(AC, itemParent);
// insert additionals childs
for (auto i : additional->getAdditionalChilds()) {
showAttributeCarrierChilds(i, additionalItem);
}
}
}
break;
}
}
}
FXTreeItem*
GNEFrame::ACHierarchy::showAttributeCarrierParents() {
// Switch gl type of ac
switch (myAC->getTag()) {
case SUMO_TAG_EDGE: {
// obtain Edge
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(myAC->getID(), false);
if(edge) {
// insert Junctions of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
// return junction destiny Item
return junctionDestinyItem;
} else {
return nullptr;
}
}
case SUMO_TAG_LANE: {
// obtain lane
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(myAC->getID(), false);
if(lane) {
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(lane->getParentEdge().getID());
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
// return edge item
return edgeItem;
} else {
return nullptr;
}
}
case SUMO_TAG_POILANE: {
// Obtain POILane
GNEPOI* POILane = myFrameParent->getViewNet()->getNet()->retrievePOI(myAC->getID(), false);
if(POILane) {
// obtain lane parent
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(POILane->getLane()->getID());
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(lane->getParentEdge().getID());
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Create lane item
FXTreeItem* laneItem = myTreelist->insertItem(0, edgeItem, lane->getHierarchyName().c_str(), lane->getIcon(), lane->getIcon());
laneItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
myTreeItemToACMap[laneItem] = lane;
// return Lane item
return laneItem;
} else {
return nullptr;
}
}
case SUMO_TAG_CROSSING: {
// obtain Crossing
GNECrossing* crossing = myFrameParent->getViewNet()->getNet()->retrieveCrossing(myAC->getID(), false);
if(crossing) {
// obtain junction
GNEJunction* junction = crossing->getParentJunction();
// create junction item
FXTreeItem* junctionItem = myTreelist->insertItem(nullptr, nullptr, junction->getHierarchyName().c_str(), junction->getIcon(), junction->getIcon());
junctionItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionItem] = junction;
// return junction Item
return junctionItem;
} else {
return nullptr;
}
}
case SUMO_TAG_CONNECTION: {
// obtain Connection
GNEConnection* connection = myFrameParent->getViewNet()->getNet()->retrieveConnection(myAC->getID(), false);
if(connection) {
// create edge from item
FXTreeItem* edgeFromItem = myTreelist->insertItem(nullptr, nullptr, connection->getEdgeFrom()->getHierarchyName().c_str(), connection->getEdgeFrom()->getIcon(), connection->getEdgeFrom()->getIcon());
edgeFromItem->setExpanded(true);
// create edge to item
FXTreeItem* edgeToItem = myTreelist->insertItem(nullptr, nullptr, connection->getEdgeTo()->getHierarchyName().c_str(), connection->getEdgeTo()->getIcon(), connection->getEdgeTo()->getIcon());
edgeToItem->setExpanded(true);
// create connection item
FXTreeItem* connectionItem = myTreelist->insertItem(0, edgeToItem, connection->getHierarchyName().c_str(), connection->getIcon(), connection->getIcon());
connectionItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[edgeFromItem] = connection->getEdgeFrom();
myTreeItemToACMap[edgeToItem] = connection->getEdgeTo();
myTreeItemToACMap[connectionItem] = connection;
// return connection item
return connectionItem;
} else {
return nullptr;
}
}
default: {
// obtain tag property (only for improve code legibility)
const auto &tagValue = GNEAttributeCarrier::getTagProperties(myAC->getTag());
// check if is an additional, and in other case return nullptr
if(tagValue.isAdditional()) {
// Obtain Additional
GNEAdditional* additional = myFrameParent->getViewNet()->getNet()->retrieveAdditional(myAC->getTag(), myAC->getID(), false);
if(additional) {
// first check if additional has another additional as parent (to add it into root)
if (tagValue.hasParent()) {
GNEAdditional* additionalParent = myFrameParent->getViewNet()->getNet()->retrieveAdditional(tagValue.getParentTag(), additional->getAttribute(GNE_ATTR_PARENT));
// create additional parent item
FXTreeItem* additionalParentItem = myTreelist->insertItem(0, 0, additionalParent->getHierarchyName().c_str(), additionalParent->getIcon(), additionalParent->getIcon());
additionalParentItem->setExpanded(true);
// Save it in myTreeItemToACMap
myTreeItemToACMap[additionalParentItem] = additionalParent;
}
if(tagValue.hasAttribute(SUMO_ATTR_EDGE)) {
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(additional->getAttribute(SUMO_ATTR_EDGE));
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
// return edge item
return edgeItem;
} else if (tagValue.hasAttribute(SUMO_ATTR_LANE)) {
// obtain lane parent
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(additional->getAttribute(SUMO_ATTR_LANE));
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(lane->getParentEdge().getID());
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Create lane item
FXTreeItem* laneItem = myTreelist->insertItem(0, edgeItem, lane->getHierarchyName().c_str(), lane->getIcon(), lane->getIcon());
laneItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
myTreeItemToACMap[laneItem] = lane;
// return lane item
return laneItem;
}
}
}
return nullptr;
}
}
}
// Draw item list
long GMTreeList::onPaint(FXObject*,FXSelector,void* ptr){
FXEvent* event=(FXEvent*)ptr;
FXTreeItem* item=firstitem;
FXTreeItem* p;
FXint yh,xh,x,y,w,h,xp,hh,cc=0;
FXDCWindow dc(this,event);
dc.setFont(font);
x=pos_x;
y=pos_y;
if(options&TREELIST_ROOT_BOXES) x+=(4+indent);
while(item && y<event->rect.y+event->rect.h){
w=item->getWidth(this);
h=item->getHeight(this);
cc++;
if(event->rect.y<=y+h){
// Draw item
dc.setForeground(backColor);
dc.fillRectangle(0,y,width,h);
if (!item->isSelected()) {
if (cc%2) {
// dc.setForeground(backColor);
// dc.fillRectangle(0,y,x+2,h);
dc.setForeground(rowcolor);
dc.fillRectangle(x,y,width-x,h);
// dc.fillRectangle(x+2,y,width-x-2,h);
}
else {
dc.setForeground(backColor);
dc.fillRectangle(0,y,width,h);
}
}
else {
// dc.setForeground(backColor);
// dc.fillRectangle(0,y,x+2,h);
dc.setForeground(getSelBackColor());
// dc.fillRectangle(x+2,y,width-x-2,h);
dc.fillRectangle(x,y,width-x,h);
}
dynamic_cast<GMTreeItem*>(item)->draw(this,dc,x,y,w,h);
// Show other paraphernalia such as dotted lines and expand-boxes
if((options&(TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES)) && (((GMTreeItem*)item)->parent || (options&TREELIST_ROOT_BOXES))){
hh=h/2;
yh=y+hh;
xh=x-indent+(SIDE_SPACING/2);
dc.setForeground(lineColor);
dc.setBackground(backColor);
dc.setStipple(STIPPLE_GRAY,pos_x&1,pos_y&1);
if(options&TREELIST_SHOWS_LINES){ // Connect items with lines
p=((GMTreeItem*)item)->parent;
xp=xh;
dc.setFillStyle(FILL_OPAQUESTIPPLED);
while(p){
xp-=(indent+p->getHeight(this)/2);
if(((GMTreeItem*)p)->next) dc.fillRectangle(xp,y,1,h);
p=((GMTreeItem*)p)->parent;
}
if((options&TREELIST_SHOWS_BOXES) && (item->hasItems() || item->getFirst())){
if(((GMTreeItem*)item)->prev || ((GMTreeItem*)item)->parent) dc.fillRectangle(xh,y,1,yh-y-HALFBOX_SIZE);
if(((GMTreeItem*)item)->next) dc.fillRectangle(xh,yh+HALFBOX_SIZE,1,y+h-yh-HALFBOX_SIZE);
}
else{
if(((GMTreeItem*)item)->prev || ((GMTreeItem*)item)->parent) dc.fillRectangle(xh,y,1,hh);
if(((GMTreeItem*)item)->next) dc.fillRectangle(xh,yh,1,h);
dc.fillRectangle(xh,yh,x+(SIDE_SPACING/2)-2-xh,1);
}
dc.setFillStyle(FILL_SOLID);
}
// Boxes before items for expand/collapse of item
if((options&TREELIST_SHOWS_BOXES) && (item->hasItems() || item->getFirst())){
dc.setFillStyle(FILL_OPAQUESTIPPLED);
dc.fillRectangle(xh+4,yh,(SIDE_SPACING/2)-2,1);
dc.setFillStyle(FILL_SOLID);
dc.drawRectangle(xh-HALFBOX_SIZE,yh-HALFBOX_SIZE,HALFBOX_SIZE+HALFBOX_SIZE,HALFBOX_SIZE+HALFBOX_SIZE);
dc.setForeground(textColor);
dc.fillRectangle(xh-HALFBOX_SIZE+2,yh,HALFBOX_SIZE+HALFBOX_SIZE-3,1);
if(!(options&TREELIST_AUTOSELECT) && !item->isExpanded()){
dc.fillRectangle(xh,yh-HALFBOX_SIZE+2,1,HALFBOX_SIZE+HALFBOX_SIZE-3);
}
}
}
}
y+=h;
// Move on to the next item
if(((GMTreeItem*)item)->first && ((options&TREELIST_AUTOSELECT) || ((GMTreeItem*)item)->isExpanded())){
x+=(indent+h/2);
item=((GMTreeItem*)item)->first;
continue;
}
while(!((GMTreeItem*)item)->next && ((GMTreeItem*)item)->parent){
item=((GMTreeItem*)item)->parent;
x-=(indent+item->getHeight(this)/2);
}
item=((GMTreeItem*)item)->next;
}
if(y<event->rect.y+event->rect.h){
dc.setForeground(backColor);
dc.fillRectangle(event->rect.x,y,event->rect.w,event->rect.y+event->rect.h-y);
}
return 1;
}