예제 #1
0
	void MultiListBox::swapItemsAt(size_t _index1, size_t _index2)
	{
		MYGUI_ASSERT(!mVectorColumnInfo.empty(), "MultiListBox::removeItemAt");
		MYGUI_ASSERT_RANGE(_index1, mVectorColumnInfo.begin()->list->getItemCount(), "MultiListBox::swapItemsAt");
		MYGUI_ASSERT_RANGE(_index2, mVectorColumnInfo.begin()->list->getItemCount(), "MultiListBox::swapItemsAt");

		// при сортированном, меняем только индексы
		BiIndexBase::swapItemsFaceAt(_index1, _index2);

		// при несортированном, нужно наоборот, поменять только данные
		// FIXME
	}
예제 #2
0
	void ListBox::swapItemsAt(size_t _index1, size_t _index2)
	{
		MYGUI_ASSERT_RANGE(_index1, mItemsInfo.size(), "ListBox::swapItemsAt");
		MYGUI_ASSERT_RANGE(_index2, mItemsInfo.size(), "ListBox::swapItemsAt");

		if (_index1 == _index2) return;

		std::swap(mItemsInfo[_index1], mItemsInfo[_index2]);

		Base::redrawItemAt(_index1);
		Base::redrawItemAt(_index2);
	}
예제 #3
0
	void ImageBox::insertItemFrameDublicate(size_t _index, size_t _indexFrame, size_t _indexSourceFrame)
	{
		MYGUI_ASSERT_RANGE(_index, mItems.size(), "ImageBox::insertItemFrameDublicate");

		VectorImages::iterator iter = mItems.begin() + _index;
		MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "ImageBox::insertItemFrameDublicate");
		if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;

		MYGUI_ASSERT_RANGE(_indexSourceFrame, iter->images.size(), "ImageBox::insertItemFrameDublicate");

		iter->images.insert(iter->images.begin() + _indexFrame, iter->images[_indexSourceFrame]);
	}
예제 #4
0
	void ListBox::removeItemAt(size_t _index)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "ListBox::removeItemAt");
		mItemsInfo.erase(mItemsInfo.begin() + _index);

		Base::removeItemAt(_index);
	}
예제 #5
0
	size_t BiIndexBase::removeItemAt(size_t _index)
	{
		#if MYGUI_DEBUG_MODE == 1
			MYGUI_ASSERT_RANGE(_index, mIndexFace.size(), "BiIndexBase::removeItemAt");
			checkIndexes();
		#endif

		// для удаления айтема
		size_t index = mIndexFace[_index];

		mIndexFace.erase(mIndexFace.begin() + _index);
		mIndexBack.pop_back();

		size_t count = mIndexFace.size();
		for (size_t pos = 0; pos < count; ++pos)
		{
			if (mIndexFace[pos] > index)
				mIndexFace[pos]--;
			mIndexBack[mIndexFace[pos]] = pos;
		}

		#if MYGUI_DEBUG_MODE == 1
			checkIndexes();
		#endif

		return index;
	}
예제 #6
0
	void ListCtrl::_setContainerItemInfo(size_t _index, bool _set, bool _accept)
	{
		if (_index == ITEM_NONE) return;
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "ListCtrl::_setContainerItemInfo");

		mIndexAccept = (_set && _accept ) ? _index : ITEM_NONE;
		mIndexRefuse = (_set && !_accept) ? _index : ITEM_NONE;

		//FIXME потом только один попробовать обновить
		_updateAllVisible(_index, true, false);

		/*size_t start = (size_t)mFirstVisibleIndex;
		if ((_index >= start) && (_index < (start + mVectorItems.size())))
		{

			IBDrawItemInfo data(_index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, false, false);

			IntCoord coord(IntPoint(), mItemsInfo[_index].size);

			requestDrawItem(this, mVectorItems[_index - start], data, coord);

			mItemsInfo[_index].size = coord.size();

		}*/
	}
예제 #7
0
    void MultiListBox::removeItemAt(size_t _index)
    {
        MYGUI_ASSERT(!mVectorColumnInfo.empty(), "MultiListBox::removeItemAt");
        MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.begin()->list->getItemCount(), "MultiListBox::removeItemAt");

        size_t index = BiIndexBase::removeItemAt(_index);

        for (VectorColumnInfo::iterator iter = mVectorColumnInfo.begin(); iter != mVectorColumnInfo.end(); ++iter)
        {
            (*iter).list->removeItemAt(index);
        }

        // если надо, то меняем выделенный элемент
        size_t count = mVectorColumnInfo.begin()->list->getItemCount();
        if (count == 0)
            mItemSelected = ITEM_NONE;
        else if (mItemSelected != ITEM_NONE)
        {
            if (_index < mItemSelected)
                mItemSelected --;
            else if ((_index == mItemSelected) && (mItemSelected == count))
                mItemSelected --;
        }
        updateBackSelected(BiIndexBase::convertToBack(mItemSelected));
    }
예제 #8
0
	Widget* ItemBox::getItemWidget(size_t _index)
	{
		// еще нет такого виджета, нуно создать
		if (_index == mVectorItems.size())
		{
			requestItemSize();

			Widget* item = _getClientWidget()->createWidget<Widget>("Default", IntCoord(0, 0, mSizeItem.width, mSizeItem.height), Align::Default);

			// вызываем запрос на создание виджета
			requestCreateWidgetItem(this, item);

			item->eventMouseWheel += newDelegate(this, &ItemBox::notifyMouseWheel);
			item->eventRootMouseChangeFocus += newDelegate(this, &ItemBox::notifyRootMouseChangeFocus);
			item->eventMouseButtonPressed += newDelegate(this, &ItemBox::notifyMouseButtonPressed);
			item->eventMouseButtonReleased += newDelegate(this, &ItemBox::notifyMouseButtonReleased);
			item->eventMouseButtonDoubleClick += newDelegate(this, &ItemBox::notifyMouseButtonDoubleClick);
			item->eventMouseDrag += newDelegate(this, &ItemBox::notifyMouseDrag);
			item->_setContainer(this);
			item->eventKeyButtonPressed += newDelegate(this, &ItemBox::notifyKeyButtonPressed);
			item->eventKeyButtonReleased += newDelegate(this, &ItemBox::notifyKeyButtonReleased);

			item->_setInternalData((size_t)mVectorItems.size());

			mVectorItems.push_back(item);
		}

		// запрашивать только последовательно
		MYGUI_ASSERT_RANGE(_index, mVectorItems.size(), "ItemBox::getItemWidget");

		return mVectorItems[_index];
	}
예제 #9
0
    const UString& MultiListBox::getSubItemNameAt(size_t _column, size_t _index)
    {
        MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.begin()->list->getItemCount(), "MultiListBox::getSubItemNameAt");

        size_t index = BiIndexBase::convertToBack(_index);
        return getSubItemAt(_column)->getItemNameAt(index);
    }
예제 #10
0
	void ItemBox::removeItemAt(size_t _index)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "ItemBox::removeItemAt");

		_resetContainer(false);
		resetCurrentActiveItem();

		mItemsInfo.erase(mItemsInfo.begin() + _index);

		// расчитываем новый индекс выделения
		if (mIndexSelect != ITEM_NONE)
		{
			if (mItemsInfo.empty())
			{
				mIndexSelect = ITEM_NONE;
			}
			else if ((mIndexSelect > _index) || (mIndexSelect == mItemsInfo.size()))
			{
				mIndexSelect --;
			}
		}

		updateScrollSize();
		updateScrollPosition();

		findCurrentActiveItem();

		_updateAllVisible(true);
	}
예제 #11
0
	void ItemBox::notifyRootMouseChangeFocus(Widget* _sender, bool _focus)
	{
		size_t index = calcIndexByWidget(_sender);
		if (_focus)
		{
			MYGUI_ASSERT_RANGE(index, mItemsInfo.size(), "ItemBox::notifyRootMouseChangeFocus");

			// сбрасываем старый
			if (mIndexActive != ITEM_NONE)
			{
				size_t old_index = mIndexActive;
				mIndexActive = ITEM_NONE;
				IBDrawItemInfo data(old_index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, false, false);
				requestDrawItem(this, mVectorItems[old_index - (mFirstVisibleIndex * mCountItemInLine)], data);
			}

			mIndexActive = index;
			IBDrawItemInfo data(index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, false, false);
			requestDrawItem(this, mVectorItems[*_sender->_getInternalData<size_t>()], data);
		}
		else
		{
			// при сбросе виджет может быть уже скрыт, и соответсвенно отсутсвовать индекс
			// сбрасываем индекс, только если мы и есть актив
			if (index < mItemsInfo.size() && mIndexActive == index)
			{
				mIndexActive = ITEM_NONE;
				IBDrawItemInfo data(index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, false, false);
				requestDrawItem(this, mVectorItems[*_sender->_getInternalData<size_t>()], data);
			}
		}
	}
예제 #12
0
	void BiIndexData::removeItemAt(size_t _index)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "BiIndexData::removeItemAt");

		size_t index = BiIndexBase::removeItemAt(_index);
		mItemsInfo.erase(mItemsInfo.begin() + index);
	}
예제 #13
0
    void MultiListBox::setSubItemDataAt(size_t _column, size_t _index, Any _data)
    {
        MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.begin()->list->getItemCount(), "MultiListBox::setSubItemDataAt");

        size_t index = BiIndexBase::convertToBack(_index);
        getSubItemAt(_column)->setItemDataAt(index, _data);
    }
예제 #14
0
	Widget* MenuControl::createItemChildByType(size_t _index, const std::string& _type)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuControl::createItemChildByType");
		removeItemChildAt(_index);
		Widget* child = mItemsInfo[_index].item->createWidgetT(WidgetStyle::Popup, _type, mSubMenuSkin, IntCoord(), Align::Default, mSubMenuLayer);
		MYGUI_ASSERT(child->isType<MenuControl>(), "child must have MenuControl base type");
		return child;
	}
예제 #15
0
 void MultiListBox::setColumnNameAt(size_t _column, const UString& _name)
 {
     MYGUI_ASSERT_RANGE(_column, mVectorColumnInfo.size(), "MultiListBox::setColumnNameAt");
     mVectorColumnInfo[_column].name = _name;
     // обновляем кэпшен сначала
     redrawButtons();
     updateColumns();
 }
예제 #16
0
    void MultiListBox::removeColumnAt(size_t _column)
    {
        MYGUI_ASSERT_RANGE(_column, mVectorColumnInfo.size(), "MultiListBox::removeColumnAt");

        ColumnInfo& info = mVectorColumnInfo[_column];

        WidgetManager::getInstance().destroyWidget(info.item);
    }
예제 #17
0
    void ListBox::notifyMousePressed(Widget* _sender, int _left, int _top, MouseButton _id)
    {
        if (MouseButton::Left != _id)
            return;

        if (_sender == mWidgetScroll)
            return;

        // если выделен клиент, то сбрасываем
        if (_sender == _getClientWidget())
        {
            if (mIndexSelect != ITEM_NONE)
            {
                _selectIndex(mIndexSelect, false);
                mIndexSelect = ITEM_NONE;
                eventListChangePosition(this, mIndexSelect);
            }
            eventListMouseItemActivate(this, mIndexSelect);

            // если не клиент, то просчитывам
        }
        // ячейка может быть скрыта
        else if (_sender->getVisible())
        {

#if MYGUI_DEBUG_MODE == 1
            _checkMapping("ListBox::notifyMousePressed");
            MYGUI_ASSERT_RANGE(*_sender->_getInternalData<size_t>(), mWidgetLines.size(), "ListBox::notifyMousePressed");
            MYGUI_ASSERT_RANGE(*_sender->_getInternalData<size_t>() + mTopIndex, mItemsInfo.size(), "ListBox::notifyMousePressed");
#endif

            size_t index = *_sender->_getInternalData<size_t>() + mTopIndex;

            if (mIndexSelect != index)
            {
                _selectIndex(mIndexSelect, false);
                _selectIndex(index, true);
                mIndexSelect = index;
                eventListChangePosition(this, mIndexSelect);
            }
            eventListMouseItemActivate(this, mIndexSelect);
        }

        _resetContainer(true);
    }
예제 #18
0
	void ImageBox::deleteItemFrame(size_t _index, size_t _indexFrame)
	{
		MYGUI_ASSERT_RANGE(_index, mItems.size(), "ImageBox::deleteItemFrame");

		VectorImages::iterator iter = mItems.begin() + _index;
		MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "ImageBox::deleteItemFrame");
		if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;

		iter->images.erase(iter->images.begin() + _indexFrame);
	}
예제 #19
0
	void ImageBox::setItem(size_t _index, const IntCoord& _item)
	{
		MYGUI_ASSERT_RANGE(_index, mItems.size(), "ImageBox::setItem");

		VectorImages::iterator iter = mItems.begin() + _index;
		iter->images.clear();
		iter->images.push_back(CoordConverter::convertTextureCoord(_item, mSizeTexture));

		if (_index == mIndexSelect) updateSelectIndex(mIndexSelect);
	}
예제 #20
0
    void ListBox::notifyMouseSetFocus(Widget* _sender, Widget* _old)
    {

#if MYGUI_DEBUG_MODE == 1
        MYGUI_ASSERT_RANGE(*_sender->_getInternalData<size_t>(), mWidgetLines.size(), "ListBox::notifyMouseSetFocus");
#endif

        mLineActive = *_sender->_getInternalData<size_t>();
        eventListMouseItemFocus(this, mLineActive);
    }
예제 #21
0
	void MenuControl::setItemNameAt(size_t _index, const UString& _name)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuControl::setItemNameAt");

		mItemsInfo[_index].name = _name;
		MenuItem* item = mItemsInfo[_index].item;
		item->setCaption(_name);

		update();
	}
예제 #22
0
    void MultiListBox::setSubItemNameAt(size_t _column, size_t _index, const UString& _name)
    {
        MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.begin()->list->getItemCount(), "MultiListBox::setSubItemAt");

        size_t index = BiIndexBase::convertToBack(_index);
        getSubItemAt(_column)->setItemNameAt(index, _name);

        // если мы попортили список с активным сортом, надо пересчитывать
        if (_column == mSortColumnIndex)
            frameAdvise(true);
    }
예제 #23
0
	size_t ItemBox::getIndexByWidget(Widget* _widget)
	{
		MYGUI_ASSERT(_widget, "ItemBox::getIndexByWidget : Widget == nullptr");
		if (_widget == _getClientWidget()) return ITEM_NONE;
		MYGUI_ASSERT(_widget->getParent() == _getClientWidget(), "ItemBox::getIndexByWidget : Widget is not child");

		size_t index = calcIndexByWidget(_widget);
		MYGUI_ASSERT_RANGE(index, mItemsInfo.size(), "ItemBox::getIndexByWidget");

		return index;
	}
예제 #24
0
	void ItemBox::redrawItemAt(size_t _index)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "ItemBox::redrawItemAt");

		size_t start = (size_t)(mFirstVisibleIndex * mCountItemInLine);
		if ((_index >= start) && (_index < (start + mVectorItems.size())))
		{
			IBDrawItemInfo data(_index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, true, false);
			requestDrawItem(this, mVectorItems[_index - start], data);
		}
	}
예제 #25
0
	void ImageBox::insertItemFrame(size_t _index, size_t _indexFrame, const IntCoord& _item)
	{
		MYGUI_ASSERT_RANGE(_index, mItems.size(), "ImageBox::insertItemFrame");

		VectorImages::iterator iter = mItems.begin() + _index;
		MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "ImageBox::insertItemFrame");
		if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;

		iter->images.insert(iter->images.begin() + _indexFrame,
			CoordConverter::convertTextureCoord(_item, mSizeTexture));
	}
예제 #26
0
void PanelView::removeItemAt(size_t _index)
{
	MYGUI_ASSERT_RANGE(_index, mItems.size(), "PanelView::removeItemAt");

	PanelCell * cell = mItems[_index]->getPanelCell();
	mItems[_index]->shutdownCell();
	delete cell;

	mItems.erase(mItems.begin() + _index);
	setNeedUpdate();
}
예제 #27
0
	void MenuControl::removeItemAt(size_t _index)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuControl::removeItemAt");

		if (mItemsInfo[_index].submenu)
		{
			WidgetManager::getInstance().destroyWidget(mItemsInfo[_index].submenu);
			mItemsInfo[_index].submenu = nullptr;
		}
		WidgetManager::getInstance().destroyWidget(mItemsInfo[_index].item);
	}
예제 #28
0
	void ImageBox::deleteItem(size_t _index)
	{
		MYGUI_ASSERT_RANGE(_index, mItems.size(), "ImageBox::deleteItem");

		mItems.erase(mItems.begin() + _index);

		if (mIndexSelect != ITEM_NONE)
		{
			if (mItems.empty()) updateSelectIndex(ITEM_NONE);
			else if ((_index < mIndexSelect) || (mIndexSelect == mItems.size())) updateSelectIndex(mIndexSelect--);
		}
	}
예제 #29
0
	void ListCtrl::notifyRootMouseChangeFocus(Widget* _sender, bool _focus)
	{
		size_t index = calcIndexByWidget(_sender);
		if (_focus)
		{
			MYGUI_ASSERT_RANGE(index, mItemsInfo.size(), "ListCtrl::notifyRootMouseChangeFocus");

			// сбрасываем старый
			if (mIndexActive != ITEM_NONE)
			{
				size_t old_index = mIndexActive;
				mIndexActive = ITEM_NONE;

				//FIXME потом только один попробовать обновить
				_updateAllVisible(old_index, true, false);

				/*IBDrawItemInfo data(old_index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, false, false);
				IntCoord coord(IntPoint(), mItemsInfo[old_index].size);
				requestDrawItem(this, mVectorItems[old_index - mFirstVisibleIndex], data, coord);
				mItemsInfo[old_index].size = coord.size();*/

			}

			mIndexActive = index;

			//FIXME потом только один попробовать обновить
			_updateAllVisible(index, true, false);

			/*IBDrawItemInfo data(index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, false, false);
			IntCoord coord(IntPoint(), mItemsInfo[index].size);
			requestDrawItem(this, mVectorItems[*_sender->_getInternalData<size_t>()], data, coord);
			mItemsInfo[index].size = coord.size();*/

		}
		else
		{
			// при сбросе виджет может быть уже скрыт, и соответсвенно отсутсвовать индекс
			// сбрасываем индекс, только если мы и есть актив
			if (index < mItemsInfo.size() && mIndexActive == index)
			{
				mIndexActive = ITEM_NONE;

				//FIXME потом только один попробовать обновить
				_updateAllVisible(index, true, false);

				/*IBDrawItemInfo data(index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, false, false);
				IntCoord coord(IntPoint(), mItemsInfo[index].size);
				requestDrawItem(this, mVectorItems[*_sender->_getInternalData<size_t>()], data, coord);
				mItemsInfo[index].size = coord.size();*/

			}
		}
	}
예제 #30
0
	void ItemBox::setItemDataAt(size_t _index, Any _data)
	{
		MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "ItemBox::setItemData");
		mItemsInfo[_index].data = _data;

		size_t start = (size_t)(mFirstVisibleIndex * mCountItemInLine);
		if ((_index >= start) && (_index < (start + mVectorItems.size())))
		{
			IBDrawItemInfo data(_index, mIndexSelect, mIndexActive, mIndexAccept, mIndexRefuse, true, false);
			requestDrawItem(this, mVectorItems[_index - start], data);
		}

		_resetContainer(true);
	}