Component* Component::getNextSiblingInNegY(void) const
{
    Component* TestComponent(NULL);
    if(getParentContainer() != NULL)
    {
        for(UInt32 i(0) ; getParentContainer()->getMFChildren()->size(); ++i)
        {
            if(getParentContainer()->getChildren(i)->getPosition().y() <= getPosition().y() &&
               (TestComponent == NULL ||
                getParentContainer()->getChildren(i)->getPosition().y() >= TestComponent->getPosition().y()))
            {
                TestComponent = getParentContainer()->getChildren(i);
            }
        }
    }

    if(TestComponent != this)
    {
        return TestComponent;
    }
    else
    {
        return NULL;
    }
}
Component* Component::getPrevDepthFirstComponent(void) const
{
    if(getParentContainer() != NULL)
    {
        Component* TestComp(getPrevSibling());
        if(TestComp == NULL)
        {
            TestComp = getParentContainer();
            while(TestComp != NULL &&
                  TestComp->getPrevSibling() == NULL)
            {
                TestComp = TestComp->getParentContainer();
            }

            if(TestComp != NULL)
            {
                TestComp = TestComp->getPrevSibling();
            }
        }

        if(TestComp != NULL &&
           TestComp->getType().isDerivedFrom(ComponentContainer::getClassType()))
        {
            return TestComp->getRightmostDecendent();
        }
        else
        {
            return TestComp;
        }
    }

    return NULL;
}
void Component::updateContainerLayout(void)
{
    if(getParentContainer() != NULL)
    {
        dynamic_cast<ComponentContainer*>(getParentContainer())->updateLayout();
    }
}
void Component::scrollToPoint(const Pnt2f& PointInComponent)
{
    if(getParentContainer() != NULL &&
       getParentContainer()->getType() == UIViewport::getClassType())
    {
        dynamic_cast<UIViewport*>(getParentContainer())->setViewPosition(PointInComponent);
    }
}
Component* Component::getPrevSibling(void) const
{
    if(getParentContainer() != NULL)
    {
        return getParentContainer()->getPrevSiblingOfChild(const_cast<Component* const>(this));
    }

    return NULL;
}
void Component::getBoundsRenderingSurfaceSpace(Pnt2f& TopLeft, Pnt2f& BottomRight) const
{
    Pnt2f ParentContainerTopLeft(0,0),ParentContainerBottomRight(0,0);
    if(getParentContainer() != NULL)
    {
        dynamic_cast<ComponentContainer*>(getParentContainer())->getBoundsRenderingSurfaceSpace(ParentContainerTopLeft, ParentContainerBottomRight);
    }
    TopLeft = ParentContainerTopLeft + Vec2f(getPosition());
    BottomRight = TopLeft + getSize();
}
示例#7
0
void CardLayout::changed(ConstFieldMaskArg whichField,
                         UInt32            origin,
                         BitVector         details)
{
    Inherited::changed(whichField, origin, details);

    if((whichField & CardFieldMask) &&
            getParentContainer() != NULL)
    {
        getParentContainer()->updateLayout();
    }
}
示例#8
0
void MenuBar::updateClipBounds(void)
{
	Pnt2f TopLeft, BottomRight;
	if(getParentWindow() == NULL)
	{
		//If I have no parent container use my bounds
		getBounds(TopLeft, BottomRight);
	}
	else
	{
		//Get the intersection of:
		     //My Bounds
		     //My Parent Containers Clip Bounds
		     //My Parent Containers Inset Bounds
        Pnt2f MyTopLeft,MyBottomRight;
        getBounds(MyTopLeft,MyBottomRight);

		//Update my Parent ComponentContainer's Clip Bounds
		//dynamic_cast<ComponentContainer*>(getParentWindow())->updateClipBounds();

		//Get Parent ComponentContainer's Clip Bounds
		Pnt2f ContainerClipTopLeft, ContainerClipBottomRight;
		dynamic_cast<InternalWindow*>(getParentContainer())->getMenuBarBounds(ContainerClipTopLeft,ContainerClipBottomRight);
		
        //Parent ComponentContainer's Clip Bounds are in the Parent ComponentContainer's Coordinate space
        //We need to convert them to this Components Coordinate space
        ContainerClipTopLeft -= Vec2f(getPosition());
		ContainerClipBottomRight -= Vec2f(getPosition());

		//Get Parent ComponentContainer's MenuBar Bounds
		Pnt2f ContainerInsetTopLeft, ContainerInsetBottomRight;
		dynamic_cast<InternalWindow*>(getParentContainer())->getMenuBarBounds(ContainerInsetTopLeft, ContainerInsetBottomRight);
		
        //Parent ComponentContainer's Inset Bounds are in the Parent ComponentContainer's Coordinate space
        //We need to convert them to this Components Coordinate space
        ContainerInsetTopLeft -= Vec2f(getPosition());
		ContainerInsetBottomRight -= Vec2f(getPosition());

		//Get the intersection of my bounds with my parent containers clip bounds
		quadIntersection(MyTopLeft,MyBottomRight,
			ContainerClipTopLeft,ContainerClipBottomRight,
			TopLeft, BottomRight);

		quadIntersection(TopLeft,BottomRight,
			ContainerInsetTopLeft,ContainerInsetBottomRight,
			TopLeft, BottomRight);
	}

	//The Clip Bounds calculated are in my Parent Containers coordinate space
	//Translate these bounds into my own coordinate space
	setClipTopLeft(TopLeft);
	setClipBottomRight(BottomRight);
}
示例#9
0
bool Container::unserializeItemNode(FileLoader& f, NODE node, PropStream& propStream)
{
	bool ret = Item::unserializeItemNode(f, node, propStream);

	if(ret){
		unsigned long type;
		NODE nodeItem = f.getChildNode(node, type);
		while(nodeItem){
			//load container items
			if(type == OTBM_ITEM){
				PropStream itemPropStream;
				f.getProps(nodeItem, itemPropStream);

				Item* item = Item::CreateItem(itemPropStream);
				if(!item){
					return false;
				}

				if(!item->unserializeItemNode(f, nodeItem, itemPropStream)){
					return false;
				}

				addItem(item);

				//deepness
				if (item->getContainer()){
					if (getParentContainer())
						item->getContainer()->setDeepness(getDeepness() + 1);
					else{ //we only update deepness when a container get inside of another, so it means that deepness is not updated
						setDeepness(1);
						item->getContainer()->setDeepness(2);
					}
				}

				updateAmountOfItems(item->getTotalAmountOfItemsInside());
				total_weight += item->getWeight();
				if(Container* parent_container = getParentContainer()) {
					parent_container->updateItemWeight(item->getWeight());

				}
			}
			else /*unknown type*/
				return false;

			nodeItem = f.getNextNode(nodeItem, type);
		}

		return true;
	}

	return false;
}
示例#10
0
void ContainerItemButton::OnRemoveItem(wxCommandEvent& WXUNUSED(event))
{
	ASSERT(edit_item);
	int ret = gui.PopupDialog(GetParent(),
		wxT("Remove Item"),
		wxT("Are you sure you want to remove this item from the container?"),
		wxYES | wxNO);

	if(ret == wxID_YES)
	{
		Container* container = getParentContainer();
		ItemVector& v = container->getVector();
		ItemVector::iterator item_index = v.begin();
		while(item_index != v.end())
		{
			if(*item_index == edit_item)
			{
				break;
			}
			++item_index;
		}
		ASSERT(item_index != v.end());

		v.erase(item_index);
		delete edit_item;

		UpdateParentContainerWindow();
	}
}
示例#11
0
void Container::__internalAddThing(uint32_t
#ifdef __DEBUG_MOVESYS__
                                   index
#endif
                                   , Thing* thing)
{
#ifdef __DEBUG_MOVESYS__
    std::clog << "[Container::__internalAddThing] index: " << index << std::endl;
#endif
    if(!thing)
        return;

    Item* item = thing->getItem();
    if(item == NULL)
    {
#ifdef __DEBUG_MOVESYS__
        std::clog << "Failure: [Container::__internalAddThing] item == NULL" << std::endl;
#endif
        return;
    }

    itemlist.push_front(item);
    item->setParent(this);

    totalWeight += item->getWeight();
    if(Container* parentContainer = getParentContainer())
        parentContainer->updateItemWeight(item->getWeight());
}
示例#12
0
void Container::updateItemWeight(double diff) 
{
	total_weight += diff;
	if(Container* parent_container = getParentContainer()) {
		parent_container->updateItemWeight(diff);
	}
}
示例#13
0
void Container::__replaceThing(uint32_t index, Thing* thing)
{
	Item* item = thing->getItem();
	if (!item) {
		return /*RET_NOTPOSSIBLE*/;
	}

	Item* replacedItem = getItemByIndex(index);
	if (!replacedItem) {
		return /*RET_NOTPOSSIBLE*/;
	}

	totalWeight -= replacedItem->getWeight();
	totalWeight += item->getWeight();

	if (Container* parentContainer = getParentContainer()) {
		parentContainer->updateItemWeight(-replacedItem->getWeight() + item->getWeight());
	}

	itemlist[index] = item;
	item->setParent(this);

	//send change to client
	if (getParent()) {
		const ItemType& oldType = Item::items[replacedItem->getID()];
		const ItemType& newType = Item::items[item->getID()];
		onUpdateContainerItem(index, replacedItem, oldType, item, newType);
	}

	replacedItem->setParent(NULL);
}
示例#14
0
void Container::__replaceThing(uint32_t index, Thing* thing)
{
	Item* item = thing->getItem();
	if (!item) {
		return /*RET_NOTPOSSIBLE*/;
	}

	Item* replacedItem = getItemByIndex(index);
	if (!replacedItem) {
		return /*RET_NOTPOSSIBLE*/;
	}

	totalWeight -= replacedItem->getWeight();
	totalWeight += item->getWeight();

	if (Container* parentContainer = getParentContainer()) {
		parentContainer->updateItemWeight(-replacedItem->getWeight() + item->getWeight());
	}

	itemlist[index] = item;
	item->setParent(this);

	//send change to client
	if (getParent()) {
		onUpdateContainerItem(index, replacedItem, item);
	}

	replacedItem->setParent(nullptr);
}
示例#15
0
void Container::__updateThing(Thing* thing, uint16_t itemId, uint32_t count)
{
	int32_t index = __getIndexOfThing(thing);
	if (index == -1) {
		return /*RET_NOTPOSSIBLE*/;
	}

	Item* item = thing->getItem();
	if (item == NULL) {
		return /*RET_NOTPOSSIBLE*/;
	}

	const ItemType& oldType = Item::items[item->getID()];
	const ItemType& newType = Item::items[itemId];

	const double oldWeight = item->getWeight();

	item->setID(itemId);
	item->setSubType(count);

	const double diffWeight = -oldWeight + item->getWeight();

	totalWeight += diffWeight;

	if (Container* parentContainer = getParentContainer()) {
		parentContainer->updateItemWeight(diffWeight);
	}

	//send change to client
	if (getParent()) {
		onUpdateContainerItem(index, item, oldType, item, newType);
	}
}
示例#16
0
void Container::updateItemWeight(int32_t diff)
{
	totalWeight += diff;
	if (Container* parentContainer = getParentContainer()) {
		parentContainer->updateItemWeight(diff);
	}
}
示例#17
0
void Container::updateAmountOfItems(int32_t diff)
{
	amountOfItems += diff;
	if(Container* parent_container = getParentContainer()){
		parent_container->updateAmountOfItems(diff);
	}
}
示例#18
0
	//-----------------------------------------------------------------------
	void gkMovableShape::setAtlasQuad(const AtlasPacker::PackResult& quad)
	{
		mMaterial = static_cast<gkVtxTexture*>(quad.texture)->getMaterial();
		RectF tex_coords = quad.node->getRect().contractedCopy(1).relativeTo(
			quad.texture->getWidth(), quad.texture->getHeight());

		const BoundingBox& bb = getBoundingBox();

		if (getParentContainer() && !(getParentContainer()->getVisible()))
		{
			mMULcolor.a = 0;
			mADDcolor.a = 0;
		}

		_lock();

		// TOP-LEFT
		_addVertex(
			D3DXVECTOR2(bb.getMinX(), -bb.getMinY()), 
			D3DXVECTOR2(tex_coords.left, tex_coords.top), 
			//D3DXVECTOR2(0, 0), 
			VTXCOLOR_TO_D3DXCOLOR(mMULcolor), VTXCOLOR_TO_D3DXCOLOR(mADDcolor));

		// BOTTOM-LEFT
		_addVertex(
			D3DXVECTOR2(bb.getMinX(), -bb.getMaxY()), 
			D3DXVECTOR2(tex_coords.left, tex_coords.bottom), 
			//D3DXVECTOR2(0, 1), 
			VTXCOLOR_TO_D3DXCOLOR(mMULcolor), VTXCOLOR_TO_D3DXCOLOR(mADDcolor));

		// BOTTOM-RIGHT
		_addVertex(
			D3DXVECTOR2(bb.getMaxX(), -bb.getMaxY()), 
			D3DXVECTOR2(tex_coords.right, tex_coords.bottom), 
			//D3DXVECTOR2(1, 1), 
			VTXCOLOR_TO_D3DXCOLOR(mMULcolor), VTXCOLOR_TO_D3DXCOLOR(mADDcolor));

		// TOP-RIGHT
		_addVertex(
			D3DXVECTOR2(bb.getMaxX(), -bb.getMinY()), 
			D3DXVECTOR2(tex_coords.right, tex_coords.top), 
			//D3DXVECTOR2(1, 0), 
			VTXCOLOR_TO_D3DXCOLOR(mMULcolor), VTXCOLOR_TO_D3DXCOLOR(mADDcolor));

		_unlock();
	}
void LLPanelSnapshot::goBack()
{
    LLSideTrayPanelContainer* parent = getParentContainer();
    if (parent)
    {
        parent->openPreviousPanel();
        parent->getCurrentPanel()->onOpen(LLSD());
    }
}
示例#20
0
void Container::__removeThing(Thing* thing, uint32_t count)
{
	Item* item = thing->getItem();
	if (item == NULL) {
		return /*RET_NOTPOSSIBLE*/;
	}

	int32_t index = __getIndexOfThing(thing);
	if (index == -1) {
		return /*RET_NOTPOSSIBLE*/;
	}

	if (item->isStackable() && count != item->getItemCount()) {
		uint8_t newCount = (uint8_t)std::max<int32_t>(0, item->getItemCount() - count);
		const double oldWeight = -item->getWeight();
		item->setItemCount(newCount);
		const double diffWeight = oldWeight + item->getWeight();
		totalWeight += diffWeight;

		//send change to client
		if (getParent()) {
			if (Container* parentContainer = getParentContainer()) {
				parentContainer->updateItemWeight(diffWeight);
			}

			const ItemType& it = Item::items[item->getID()];
			onUpdateContainerItem(index, item, it, item, it);
		}
	} else {
		//send change to client
		if (getParent()) {
			if (Container* parentContainer = getParentContainer()) {
				parentContainer->updateItemWeight(-item->getWeight());
			}

			onRemoveContainerItem(index, item);
		}

		totalWeight -= item->getWeight();
		item->setParent(NULL);
		itemlist.erase(itemlist.begin() + index);
	}
}
示例#21
0
	//-----------------------------------------------------------------------
	void gkMovableShape::_update(const float& delta_time)
	{
		Shape::_update(delta_time);

		const Matrix& mat = getWorldMatrix();

		mWorldMatrix = D3DXMATRIX(
			mat.m[0][0], -mat.m[0][1], 0,  mat.m[0][2], 
			-mat.m[1][0], mat.m[1][1], 0, -mat.m[1][2], 
			0,		  0,		   1,				0,
			0,		  0,		   0,				1);

		D3DXMatrixTranspose(&mWorldMatrix, &mWorldMatrix);

		mMULcolor = mTransform.getColor().mul;
		mADDcolor = mTransform.getColor().add;

		if (getParentContainer() && !(getParentContainer()->getVisible()))
		{
			mMULcolor.a = 0;
			mADDcolor.a = 0;
		}
	}
示例#22
0
void ContainerItemButton::OnMouseDoubleLeftClick(wxMouseEvent& WXUNUSED(event))
{
	Container* container = getParentContainer();

	bool can_add = container->getVolume() > (int)container->getVector().size();

	if(edit_item) {
		wxCommandEvent unused;
		OnEditItem(unused);
	} else if(can_add) {
		wxCommandEvent unused;
		OnAddItem(unused);
	}
}
示例#23
0
void Component::updateClipBounds(void)
{
    Pnt2f TopLeft, BottomRight;
    if((getParentContainer() == NULL && useBoundsForClipping()) ||
       (getParentContainer() && getParentContainer()->getType() == RotatedComponent::getClassType()))
    {
        //If I have no parent container use my bounds
        getBounds(TopLeft, BottomRight);
    }
    else if(getParentContainer() != NULL)
    {
        //Get the intersection of:
        //     My Bounds
        //     My Parent Containers Clip Bounds
        //     My Parent Containers Inset Bounds
        Pnt2f MyTopLeft,MyBottomRight;
        getBounds(MyTopLeft,MyBottomRight);

        //Get Parent ComponentContainer's Clip Bounds
        Pnt2f ContainerClipTopLeft, ContainerClipBottomRight;
        dynamic_cast<ComponentContainer*>(getParentContainer())->getClipBounds(ContainerClipTopLeft,ContainerClipBottomRight);

        //Parent ComponentContainer's Clip Bounds are in the Parent ComponentContainer's Coordinate space
        //We need to convert them to this Components Coordinate space
        ContainerClipTopLeft -= Vec2f(getPosition());
        ContainerClipBottomRight -= Vec2f(getPosition());

        //Get Parent ComponentContainer's Inset Bounds
        Pnt2f ContainerInsetTopLeft, ContainerInsetBottomRight;
        dynamic_cast<ComponentContainer*>(getParentContainer())->getInsideInsetsBounds(ContainerInsetTopLeft, ContainerInsetBottomRight);

        //Parent ComponentContainer's Inset Bounds are in the Parent ComponentContainer's Coordinate space
        //We need to convert them to this Components Coordinate space
        ContainerInsetTopLeft -= Vec2f(getPosition());
        ContainerInsetBottomRight -= Vec2f(getPosition());

        //Get the intersection of my bounds with my parent containers clip bounds
        quadIntersection(MyTopLeft,MyBottomRight,
                         ContainerClipTopLeft,ContainerClipBottomRight,
                         TopLeft, BottomRight);

        quadIntersection(TopLeft,BottomRight,
                         ContainerInsetTopLeft,ContainerInsetBottomRight,
                         TopLeft, BottomRight);
    }

    //The Clip Bounds calculated are in my Parent Containers coordinate space
    //Translate these bounds into my own coordinate space
    if(getClipTopLeft() != TopLeft)
    {
        setClipTopLeft(TopLeft);
    }
    if(getClipBottomRight() != BottomRight)
    {
        setClipBottomRight(BottomRight);
    }
}
示例#24
0
void Container::__internalAddThing(uint32_t index, Thing* thing)
{
	Item* item = thing->getItem();
	if (item == NULL) {
		return;
	}

	item->setParent(this);
	itemlist.push_front(item);
	totalWeight += item->getWeight();

	if (Container* parentContainer = getParentContainer()) {
		parentContainer->updateItemWeight(item->getWeight());
	}
}
示例#25
0
void AbstractWindow::updateContainerLayout(void)
{
    if(getParentContainer() != NULL)
    {
		Inherited::updateContainerLayout();
    }
	else if(getSize() != getPreferredSize())
	{
		Vec2f Size(osgMax(osgMin(getPreferredSize().x(), getMaxSize().x()), getMinSize().x()),
			       osgMax(osgMin(getPreferredSize().y(), getMaxSize().y()), getMinSize().y()));
        if(getSize() != Size)
        {
			setSize(Size);
        }
	}
}
示例#26
0
void Container::__replaceThing(uint32_t index, Thing* thing)
{
    Item* item = thing->getItem();
    if(!item)
    {
#ifdef __DEBUG_MOVESYS__
        std::clog << "Failure: [Container::__replaceThing] item == NULL" << std::endl;
#endif
        return /*RET_NOTPOSSIBLE*/;
    }

    uint32_t count = 0;
    ItemList::iterator cit = itemlist.end();
    for(cit = itemlist.begin(); cit != itemlist.end(); ++cit)
    {
        if(count == index)
            break;

        ++count;
    }

    if(cit == itemlist.end())
    {
#ifdef __DEBUG_MOVESYS__
        std::clog << "Failure: [Container::__updateThing] item not found" << std::endl;
#endif
        return /*RET_NOTPOSSIBLE*/;
    }

    totalWeight -= (*cit)->getWeight();
    totalWeight += item->getWeight();
    if(Container* parentContainer = getParentContainer())
        parentContainer->updateItemWeight(-(*cit)->getWeight() + item->getWeight());

    itemlist.insert(cit, item);
    item->setParent(this);
    //send change to client
    if(getParent())
    {
        const ItemType& oldType = Item::items[(*cit)->getID()];
        const ItemType& newType = Item::items[item->getID()];
        onUpdateContainerItem(index, *cit, oldType, item, newType);
    }

    (*cit)->setParent(NULL);
    itemlist.erase(cit);
}
示例#27
0
void ContainerItemButton::OnAddItem(wxCommandEvent& WXUNUSED(event))
{
	struct IsItem
	{
		static bool Pickupable(const ItemType& it)
		{
			return it.pickupable;
		}
	};

	FindItemDialog* d = newd FindItemDialog(this->GetParent(), wxT("Choose Item to add"));
	d->setCondition(IsItem::Pickupable);
	int id = d->ShowModal();
	d->Destroy();

	if(id != 0)
	{
		Container* container = getParentContainer();

		// Find the position where we should insert the item
		ItemVector& v = container->getVector();
		ItemVector::iterator item_index = v.begin();
		int i = 0;
		while(true) {
			if(item_index == v.end()) {
				// Insert at end of the vector
				break;
			}
			if(i == index) {
				// We found where to insert
				break;
			}
			++i;
			++item_index;
		}

		// Create and insert the item
		Item* item = Item::Create(id);
		v.insert(item_index, item);

		// Update view
		UpdateParentContainerWindow();
	}
}
示例#28
0
void Container::__addThingBack(Thing* thing)
{
	Item* item = thing->getItem();
	if (item == NULL) {
		return /*RET_NOTPOSSIBLE*/;
	}

	item->setParent(this);
	itemlist.push_back(item);
	totalWeight += item->getWeight();

	if (Container* parentContainer = getParentContainer()) {
		parentContainer->updateItemWeight(item->getWeight());
	}

	//send change to client
	if (getParent() && (getParent() != VirtualCylinder::virtualCylinder)) {
		onAddContainerItem(item);
	}
}
示例#29
0
bool Container::unserializeItemNode(FileLoader& f, NODE node, PropStream& propStream)
{
	bool ret = Item::unserializeItemNode(f, node, propStream);
	if (!ret) {
		return false;
	}

	uint32_t type;
	NODE nodeItem = f.getChildNode(node, type);
	while (nodeItem) {
		//load container items
		if (type != OTBM_ITEM) {
			// unknown type
			return false;
		}

		PropStream itemPropStream;
		if (!f.getProps(nodeItem, itemPropStream)) {
			return false;
		}

		Item* item = Item::CreateItem(itemPropStream);
		if (!item) {
			return false;
		}

		if (!item->unserializeItemNode(f, nodeItem, itemPropStream)) {
			return false;
		}

		addItem(item);
		totalWeight += item->getWeight();

		if (Container* parent_container = getParentContainer()) {
			parent_container->updateItemWeight(item->getWeight());
		}

		nodeItem = f.getNextNode(nodeItem, type);
	}
	return true;
}
示例#30
0
void Container::__addThing(Creature*, int32_t index, Thing* thing)
{
    if(index >= (int32_t)capacity())
    {
#ifdef __DEBUG_MOVESYS__
        std::clog << "Failure: [Container::__addThing], index:" << index << ", index >= capacity()" << std::endl;
#endif
        return /*RET_NOTPOSSIBLE*/;
    }

    Item* item = thing->getItem();
    if(!item)
    {
#ifdef __DEBUG_MOVESYS__
        std::clog << "Failure: [Container::__addThing] item == NULL" << std::endl;
#endif
        return /*RET_NOTPOSSIBLE*/;
    }

#ifdef __DEBUG_MOVESYS__
    if(index != INDEX_WHEREEVER && size() >= capacity())
    {
        std::clog << "Failure: [Container::__addThing] size() >= capacity()" << std::endl;
        return /*RET_CONTAINERNOTENOUGHROOM*/;
    }
#endif

    item->setParent(this);
    itemlist.push_front(item);

    totalWeight += item->getWeight();
    if(Container* parentContainer = getParentContainer())
        parentContainer->updateItemWeight(item->getWeight());

    //send change to client
    if(getParent() && getParent() != VirtualCylinder::virtualCylinder)
        onAddContainerItem(item);
}