void ZombieDarkEntity::collideWithEnemy(EnemyEntity* entity)
{
if (entity->getMovingStyle() == movWalking)
{
if (currentDirection == 6 && entity->getX() > x)
{
currentDirection = 4;
targetTile = IntCoord(currentTile.x - 1, currentTile.y);
}
else if (currentDirection == 4 && entity->getX() < x)
{
currentDirection = 6;
targetTile = IntCoord(currentTile.x + 1, currentTile.y);
}
else if (currentDirection == 8 && entity->getY() < y)
{
currentDirection = 2;
targetTile = IntCoord(currentTile.x, currentTile.y + 1);
}
else if (currentDirection == 2 && entity->getY() > y)
{
currentDirection = 8;
targetTile = IntCoord(currentTile.x, currentTile.y - 1);
}
switch (currentDirection)
{
case 4: velocity.x = - creatureSpeed; velocity.y = 0.0f; break;
case 6: velocity.x = + creatureSpeed; velocity.y = 0.0f; break;
case 2: velocity.y = + creatureSpeed; velocity.x = 0.0f; break;
case 8: velocity.y = - creatureSpeed; velocity.x = 0.0f; break;
default: break;
}
nextFacingDirection = currentDirection;
}
}
IntCoord Gui::convertRelativeToInt(const FloatCoord& _coord, WidgetPtr _parent)
{
const FloatSize& size = getViewSize();
if (null == _parent) {
return IntCoord(_coord.left * size.width, _coord.top * size.height, _coord.width * size.width, _coord.height * size.height);
}
const IntCoord& coord = _parent->getClientCoord();
return IntCoord(_coord.left * coord.width, _coord.top * coord.height, _coord.width * coord.width, _coord.height * coord.height);
}
IntCoord Window::_getActionScale(Widget* _widget)
{
if (_widget->isUserString("Scale"))
{
IntCoord result = IntCoord::parse(_widget->getUserString("Scale"));
if (result == IntCoord(1, 1, 0, 0) && !mMovable)
result.clear();
return result;
}
else if (_widget->isUserString("Action"))
{
const std::string& action = _widget->getUserString("Action");
if (action == "Move")
{
if (mMovable)
return IntCoord(1, 1, 0, 0);
else
return IntCoord();
}
IntCoord coord;
Align align = Align::parse(action);
if (align.isLeft())
{
coord.left = 1;
coord.width = -1;
}
else if (align.isRight())
{
coord.width = 1;
}
if (align.isTop())
{
coord.top = 1;
coord.height = -1;
}
else if (align.isBottom())
{
coord.height = 1;
}
return coord;
}
return IntCoord();
}
IntCoord EditText::getCursorCoord(size_t _position)
{
if (nullptr == mFont)
return IntCoord();
if (mTextOutDate)
updateRawData();
IntPoint point = mTextView.getCursorPoint(_position);
point += mCroppedParent->getAbsolutePosition();
point -= mViewOffset;
point += mCoord.point();
return IntCoord(point.left, point.top, 2, mFontHeight);
}
void Message::setWindowFade(bool _fade)
{
return; //пока пропустим
if (_fade)
{
if (nullptr == mWidgetFade)
{
Gui& gui = Gui::getInstance();
mWidgetFade = gui.createWidgetT(Widget::getClassTypeName(), mFadeSkin, IntCoord(0, 0, gui.getViewSize().width, gui.getViewSize().height), Align::Stretch, mFadeLayer);
if (mSmoothShow)
{
mWidgetFade->setVisible(false);
ControllerFadeAlpha* controller = createControllerFadeAlpha(MESSAGE_ALPHA_MAX, MESSAGE_SPEED_COEF, false);
ControllerManager::getInstance().addItem(mWidgetFade, controller);
}
else
{
mWidgetFade->setAlpha(MESSAGE_ALPHA_MAX);
}
}
}
else
{
if (nullptr != mWidgetFade)
{
WidgetManager::getInstance().destroyWidget(mWidgetFade);
mWidgetFade = nullptr;
}
}
}
void ScrollView::initialiseOverride()
{
Base::initialiseOverride();
// FIXME нам нужен фокус клавы
setNeedKeyFocus(true);
assignWidget(mClient, "Client");
if (mClient != nullptr)
{
mClient->eventMouseWheel += newDelegate(this, &ScrollView::notifyMouseWheel);
// создаем холcт, реальный владелец детей
mRealClient = mClient->createWidget<Widget>("Default", IntCoord(), Align::Default);
mRealClient->eventMouseWheel += newDelegate(this, &ScrollView::notifyMouseWheel);
setWidgetClient(mRealClient);
}
assignWidget(mVScroll, "VScroll");
if (mVScroll != nullptr)
{
mVScroll->eventScrollChangePosition += newDelegate(this, &ScrollView::notifyScrollChangePosition);
}
assignWidget(mHScroll, "HScroll");
if (mHScroll != nullptr)
{
mHScroll->eventScrollChangePosition += newDelegate(this, &ScrollView::notifyScrollChangePosition);
}
updateView();
}
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];
}
void ImageBox::recalcIndexes()
{
mItems.clear();
if ((mRectImage.right <= mRectImage.left) || (mRectImage.bottom <= mRectImage.top))
return;
if ((mSizeTile.width <= 0) || (mSizeTile.height <= 0))
return;
size_t count_h = (size_t)(mRectImage.width() / mSizeTile.width);
size_t count_v = (size_t)(mRectImage.height() / mSizeTile.height);
if ((count_h * count_v) > IMAGE_MAX_INDEX)
{
MYGUI_LOG(Warning, "Tile count very mach, rect : " << mRectImage.print() << " tile : " << mSizeTile.print() << " texture : " << _getTextureName() << " indexes : " << (count_h * count_v) << " max : " << IMAGE_MAX_INDEX);
return;
}
int pos_h = mRectImage.left;
int pos_v = mRectImage.top;
for (size_t v = 0; v < count_v; ++v)
{
for (size_t h = 0; h < count_h; ++h)
{
addItem(IntCoord(pos_h, pos_v, mSizeTile.width, mSizeTile.height));
pos_h += mSizeTile.width;
}
pos_v += mSizeTile.height;
pos_h = mRectImage.left;
}
}
void MultiListBox::insertColumnAt(size_t _column, const UString& _name, int _width, Any _data)
{
MYGUI_ASSERT_RANGE_INSERT(_column, mVectorColumnInfo.size(), "MultiListBox::insertColumnAt");
if (_column == ITEM_NONE)
_column = mVectorColumnInfo.size();
createWidget<MultiListItem>("", IntCoord(), Align::Default);
mVectorColumnInfo.back().width = _width;
mVectorColumnInfo.back().sizeType = ResizingPolicy::Fixed;
mVectorColumnInfo.back().name = _name;
mVectorColumnInfo.back().data = _data;
mVectorColumnInfo.back().button->setCaption(_name);
if (_column == (mVectorColumnInfo.size() - 1))
{
updateColumns();
mVectorColumnInfo.back().list->setScrollVisible(true);
}
else
{
_swapColumnsAt(_column, mVectorColumnInfo.size() - 1);
}
}
void MenuBar::insertItem(size_t _index, const Ogre::UTFString & _item)
{
MYGUI_ASSERT(_index < mVectorMenuItemInfo.size() || _index == ITEM_NONE, "index '" << _index << "' out of range");
if (_index == ITEM_NONE) _index = mVectorMenuItemInfo.size();
ButtonPtr button = mWidgetClient->createWidget<Button>(mButtonSkinName, IntCoord(), ALIGN_DEFAULT);
button->eventMouseButtonPressed = newDelegate(this, &MenuBar::eventMouseButtonPressed);
button->setCaption(_item);
PopupMenuPtr menu = Gui::getInstance().createWidget<PopupMenu>("PopupMenu", IntCoord(), ALIGN_DEFAULT, "Popup");
menu->eventPopupMenuClose = newDelegate(this, &MenuBar::notifyPopupMenuClose);
menu->eventPopupMenuAccept = newDelegate(this, &MenuBar::notifyPopupMenuAccept);
menu->_setOwner(this);
mVectorMenuItemInfo.insert(mVectorMenuItemInfo.begin() + _index, MenuItemInfo(button, menu));
update();
}
Button* TabControl::createButton()
{
Widget* parent = this;
if (mWidgetBar != nullptr)
parent = mWidgetBar;
else if (mHeaderPlace != nullptr)
parent = mHeaderPlace;
return parent->createWidget<Button>(mButtonSkinName, IntCoord(), Align::Left | Align::Top);
}
MenuItem* MenuControl::insertItemAt(size_t _index, const UString& _name, MenuItemType _type, const std::string& _id, Any _data)
{
MYGUI_ASSERT_RANGE_INSERT(_index, mItemsInfo.size(), "MenuControl::insertItemAt");
if (_index == ITEM_NONE) _index = mItemsInfo.size();
MenuItem* item = _getClientWidget()->createWidget<MenuItem>(getSkinByType(_type), IntCoord(), Align::Default);
_wrapItem(item, _index, _name, _type, _id, _data);
return item;
}
void MultiListBox::_wrapItem(MultiListItem* _item)
{
// скрываем у крайнего скролл
if (!mVectorColumnInfo.empty())
mVectorColumnInfo.back().list->setScrollVisible(false);
else
mSortColumnIndex = ITEM_NONE;
ColumnInfo column;
column.width = 0;
column.sizeType = ResizingPolicy::Auto;
column.item = _item;
column.list = _item->createWidget<ListBox>(mSkinList, IntCoord(0, 0, _item->getWidth(), _item->getHeight()), Align::Stretch);
column.list->eventListChangePosition += newDelegate(this, &MultiListBox::notifyListChangePosition);
column.list->eventListMouseItemActivate += newDelegate(this, &MultiListBox::notifyListMouseItemActivate);
column.list->eventListMouseItemFocus += newDelegate(this, &MultiListBox::notifyListChangeFocus);
column.list->eventListChangeScroll += newDelegate(this, &MultiListBox::notifyListChangeScrollPosition);
column.list->eventListSelectAccept += newDelegate(this, &MultiListBox::notifyListSelectAccept);
if (mHeaderPlace != nullptr)
column.button = mHeaderPlace->createWidget<Button>(mSkinButton, IntCoord(), Align::Default);
else
column.button = mClient->createWidget<Button>(mSkinButton, IntCoord(), Align::Default);
//column.button->eventMouseButtonClick += newDelegate(this, &MultiListBox::notifyButtonClick);
// если уже были столбики, то делаем то же колличество полей
if (!mVectorColumnInfo.empty())
{
size_t count = mVectorColumnInfo.front().list->getItemCount();
for (size_t pos = 0; pos < count; ++pos)
column.list->addItem("");
}
mVectorColumnInfo.push_back(column);
updateColumns();
// показываем скролл нового крайнего
mVectorColumnInfo.back().list->setScrollVisible(true);
}
WidgetPtr ItemBox::getItemWidget(size_t _index)
{
// еще нет такого виджета, нуно создать
if (_index >= mVectorItems.size()) {
int pos = mTopIndex + (int)mVectorItems.size();
WidgetPtr widget = mWidgetClient->createWidgetT("Widget", "Edit", IntCoord((pos % mCountItemInLine) * mSizeItem.width, ((pos / mCountItemInLine) * mSizeItem.height) + mOffsetTop, mSizeItem.width, mSizeItem.height), ALIGN_DEFAULT);
widget->eventMouseWheel = newDelegate(this, &ItemBox::notifyMouseWheel);
mVectorItems.push_back(widget);
return mVectorItems.back();
}
return mVectorItems[_index];
}
void WrapPanel::simpleArrange()
{
IntCoord coordAvailable(0, 0, getWidth(), getHeight());
IntPoint currentPosition = coordAvailable.point();
int maxLineHeight = 0;
bool hasAnyWidget = false;
size_t startLineIndex = 0;
size_t count = getChildCount();
for (size_t index = 0; index < count; ++ index)
{
Widget* child = getChildAt(index);
IntSize size = Panel::getDesiredSize(child);
if (((currentPosition.left + size.width) > coordAvailable.width))
{
if (hasAnyWidget)
{
alignChildLine(startLineIndex, index, IntCoord(coordAvailable.left, currentPosition.top, coordAvailable.width, maxLineHeight), currentPosition.left - mSpacer.width);
currentPosition.left = 0;
currentPosition.top += maxLineHeight + mSpacer.height;
maxLineHeight = 0;
startLineIndex = index;
}
}
currentPosition.left += size.width + mSpacer.width;
maxLineHeight = (std::max)(size.height, maxLineHeight);
hasAnyWidget = true;
}
if (startLineIndex < count)
alignChildLine(startLineIndex, count, IntCoord(coordAvailable.left, currentPosition.top, coordAvailable.width, maxLineHeight), currentPosition.left - mSpacer.width);
}
void MultiListBox::initialiseOverride()
{
Base::initialiseOverride();
std::string skinButtonEmpty;
if (isUserString("SkinButton"))
mSkinButton = getUserString("SkinButton");
if (isUserString("SkinList"))
mSkinList = getUserString("SkinList");
if (isUserString("SkinSeparator"))
mSkinSeparator = getUserString("SkinSeparator");
if (isUserString("WidthSeparator"))
mWidthSeparator = utility::parseValue<int>(getUserString("WidthSeparator"));
// OBSOLETE
if (isUserString("HeightButton"))
mHeightButton = utility::parseValue<int>(getUserString("HeightButton"));
if (mHeightButton < 0)
mHeightButton = 0;
///@wskin_child{MultiListBox, Widget, HeaderPlace} Место для заголовков колонок.
assignWidget(mHeaderPlace, "HeaderPlace");
///@wskin_child{MultiListBox, Widget, Client} Клиентская зона.
assignWidget(mClient, "Client");
if (mClient != nullptr)
setWidgetClient(mClient);
if (nullptr == mClient)
mClient = this;
///@wskin_child{MultiListBox, Widget, Empty} Виджет для заголовка в месте где нет списков.
assignWidget(mWidgetEmpty, "Empty");
if (mWidgetEmpty == nullptr)
{
if (isUserString("SkinButtonEmpty"))
skinButtonEmpty = getUserString("SkinButtonEmpty");
if (!skinButtonEmpty.empty())
mWidgetEmpty = mClient->createWidget<Widget>(skinButtonEmpty, IntCoord(0, 0, mClient->getWidth(), getButtonHeight()), Align::Default);
}
if (getUpdateByResize())
updateColumns();
}
int TabControl::_getTextWidth(const UString& _text)
{
if (mItemButton.empty())
_createItemButton();
UString save = mItemButton[0]->getCaption();
mItemButton[0]->setCaption(_text);
ISubWidgetText* text = mItemButton[0]->getSubWidgetText();
const IntSize& size = text ? text->getTextSize() : IntSize();
const IntCoord& coord = text ? text->getCoord() : IntCoord();
mItemButton[0]->setCaption(save);
return size.width + mItemButton[0]->getWidth() - coord.width;
}
Widget* MultiListBox::getSeparator(size_t _index)
{
if (!mWidthSeparator || mSkinSeparator.empty())
return nullptr;
// последний столбик
if (_index == mVectorColumnInfo.size() - 1)
return nullptr;
while (_index >= mSeparators.size())
{
Widget* separator = mClient->createWidget<Widget>(mSkinSeparator, IntCoord(), Align::Default);
mSeparators.push_back(separator);
}
return mSeparators[_index];
}
void MultiListBox::initialiseOverride()
{
Base::initialiseOverride();
std::string skinButtonEmpty;
if (isUserString("SkinButton"))
mSkinButton = getUserString("SkinButton");
if (isUserString("SkinList"))
mSkinList = getUserString("SkinList");
if (isUserString("SkinSeparator"))
mSkinSeparator = getUserString("SkinSeparator");
if (isUserString("WidthSeparator"))
mWidthSeparator = utility::parseValue<int>(getUserString("WidthSeparator"));
// OBSOLETE
if (isUserString("HeightButton"))
mHeightButton = utility::parseValue<int>(getUserString("HeightButton"));
if (mHeightButton < 0)
mHeightButton = 0;
assignWidget(mHeaderPlace, "HeaderPlace");
assignWidget(mClient, "Client");
if (mClient != nullptr)
setWidgetClient(mClient);
if (nullptr == mClient)
mClient = this;
assignWidget(mWidgetEmpty, "Empty");
if (mWidgetEmpty == nullptr)
{
if (isUserString("SkinButtonEmpty"))
skinButtonEmpty = getUserString("SkinButtonEmpty");
if (!skinButtonEmpty.empty())
mWidgetEmpty = mClient->createWidget<Widget>(skinButtonEmpty, IntCoord(0, 0, mClient->getWidth(), getButtonHeight()), Align::Default);
}
if (getUpdateByResize())
updateColumns();
}
void ItemBox::updateDropItems()
{
if (nullptr == mItemDrag)
{
// спрашиваем размер иконок
IntCoord coord;
requestCoordItem(this, coord, true);
mPointDragOffset = coord.point();
// создаем и запрашиваем детей
mItemDrag = Gui::getInstance().createWidget<Widget>("Default", IntCoord(0, 0, coord.width, coord.height), Align::Default, mDragLayer);
requestCreateWidgetItem(this, mItemDrag);
}
const IntPoint& point = InputManager::getInstance().getMousePosition();
mItemDrag->setPosition(point.left - mClickInWidget.left + mPointDragOffset.left, point.top - mClickInWidget.top + mPointDragOffset.top);
mItemDrag->setVisible(true);
}
void ScrollView::initialiseWidgetSkin(ResourceSkin* _info)
{
// нам нужен фокус клавы
mNeedKeyFocus = true;
for (VectorWidgetPtr::iterator iter=mWidgetChildSkin.begin(); iter!=mWidgetChildSkin.end(); ++iter)
{
if (*(*iter)->_getInternalData<std::string>() == "Client")
{
MYGUI_DEBUG_ASSERT( ! mScrollClient, "widget already assigned");
mScrollClient = (*iter);
mScrollClient->eventMouseSetFocus = newDelegate(this, &ScrollView::notifyMouseSetFocus);
mScrollClient->eventMouseLostFocus = newDelegate(this, &ScrollView::notifyMouseLostFocus);
mScrollClient->eventMouseWheel = newDelegate(this, &ScrollView::notifyMouseWheel);
mClient = mScrollClient;
// создаем холcт, реальный владелец детей
mWidgetClient = mScrollClient->createWidget<Widget>("Default", IntCoord(), Align::Default);
mWidgetClient->eventMouseWheel = newDelegate(this, &ScrollView::notifyMouseWheel);
mWidgetClient->eventMouseSetFocus = newDelegate(this, &ScrollView::notifyMouseSetFocus);
mWidgetClient->eventMouseLostFocus = newDelegate(this, &ScrollView::notifyMouseLostFocus);
}
else if (*(*iter)->_getInternalData<std::string>() == "VScroll")
{
MYGUI_DEBUG_ASSERT( ! mVScroll, "widget already assigned");
mVScroll = (*iter)->castType<VScroll>();
mVScroll->eventScrollChangePosition = newDelegate(this, &ScrollView::notifyScrollChangePosition);
}
else if (*(*iter)->_getInternalData<std::string>() == "HScroll")
{
MYGUI_DEBUG_ASSERT( ! mHScroll, "widget already assigned");
mHScroll = (*iter)->castType<HScroll>();
mHScroll->eventScrollChangePosition = newDelegate(this, &ScrollView::notifyScrollChangePosition);
}
}
//MYGUI_ASSERT(nullptr != mScrollClient, "Child Widget Client not found in skin (ScrollView must have Client)");
updateView();
}
MyGUI::Message* Message::createMessageBox(
const std::string& _skin,
const UString& _caption,
const UString& _message,
MessageBoxStyle _style,
const std::string& _layer,
bool _modal,
const std::string& _button1,
const std::string& _button2,
const std::string& _button3,
const std::string& _button4)
{
Message* mess = Gui::getInstance().createWidget<Message>(_skin, IntCoord(), Align::Default, _layer);
mess->setCaption(_caption);
mess->setMessageText(_message);
mess->setSmoothShow(true);
if (_modal) mess->setWindowFade(true);
mess->setMessageStyle(_style);
if (!_button1.empty())
{
mess->addButtonName(_button1);
if (!_button2.empty())
{
mess->addButtonName(_button2);
if (!_button3.empty())
{
mess->addButtonName(_button3);
}
}
}
if (_layer.empty()) LayerManager::getInstance().attachToLayerNode(mess->getDefaultLayer(), mess);
if (_modal) InputManager::getInstance().addWidgetModal(mess);
return mess;
}
void WrapPanel::alignChildLine(size_t _startIndex, size_t _stopIndex, const IntCoord& _coordAvailable, int _lineWidth)
{
int left = _coordAvailable.left;
if (mContentAlign.isHCenter())
left = _coordAvailable.left + ((_coordAvailable.width - _lineWidth) / 2);
else if (mContentAlign.isRight())
left = _coordAvailable.left + (_coordAvailable.width - _lineWidth);
for (size_t index = _startIndex; index < _stopIndex; ++ index)
{
Widget* child = getChildAt(index);
IntSize size = Panel::getDesiredSize(child);
int top = _coordAvailable.top;
if (mContentAlign.isVCenter())
top = _coordAvailable.top + ((_coordAvailable.height - size.height) / 2);
else if (mContentAlign.isBottom())
top = _coordAvailable.top + (_coordAvailable.height - size.height);
Panel::updateArrange(child, IntCoord(left, top, size.width, size.height));
left += size.width + mSpacer.width;
}
}
void ScrollView::initialiseOverride()
{
Base::initialiseOverride();
// FIXME нам нужен фокус клавы
setNeedKeyFocus(true);
///@wskin_child{ScrollView, Widget, Client} Клиентская зона.
assignWidget(mClient, "Client");
MyGUI::Widget* realClientOwner = this;
if (mClient != nullptr)
{
mClient->eventMouseWheel += newDelegate(this, &ScrollView::notifyMouseWheel);
realClientOwner = mClient;
}
// создаем холcт, реальный владелец детей
mRealClient = realClientOwner->createWidget<Widget>("Default", IntCoord(), Align::Default);
mRealClient->eventMouseWheel += newDelegate(this, &ScrollView::notifyMouseWheel);
setWidgetClient(mRealClient);
///@wskin_child{ScrollView, ScrollBar, VScroll} Вертикальная полоса прокрутки.
assignWidget(mVScroll, "VScroll");
if (mVScroll != nullptr)
{
mVScroll->eventScrollChangePosition += newDelegate(this, &ScrollView::notifyScrollChangePosition);
}
///@wskin_child{ScrollView, ScrollBar, HScroll} Горизонтальная полоса прокрутки.
assignWidget(mHScroll, "HScroll");
if (mHScroll != nullptr)
{
mHScroll->eventScrollChangePosition += newDelegate(this, &ScrollView::notifyScrollChangePosition);
}
updateView();
}
void ImageBox::setItemResourceInfo(const ImageIndexInfo& _info)
{
mCurrentTextureName = _info.texture;
mSizeTexture = texture_utility::getTextureSize(mCurrentTextureName);
mItems.clear();
if (_info.frames.size() != 0)
{
std::vector<IntPoint>::const_iterator iter = _info.frames.begin();
addItem(IntCoord(*iter, _info.size));
setItemFrameRate(0, _info.rate);
for (++iter; iter != _info.frames.end(); ++iter)
{
addItemFrame(0, MyGUI::IntCoord(*iter, _info.size));
}
}
mIndexSelect = 0;
updateSelectIndex(mIndexSelect);
}
MessageBoxStyle Message::addButtonName(const UString& _name)
{
//FIXME
if (mVectorButton.size() >= MessageBoxStyle::_CountUserButtons)
{
MYGUI_LOG(Warning, "Too many buttons in message box, ignored");
return MessageBoxStyle::None;
}
// бит, номер кнопки + смещение до Button1
MessageBoxStyle info = MessageBoxStyle(MessageBoxStyle::Enum(MYGUI_FLAG(mVectorButton.size() + MessageBoxStyle::_IndexUserButton1)));
// запоминаем кнопки для отмены и подтверждения
if (mVectorButton.empty()) mInfoOk = info;
mInfoCancel = info;
Widget* button = createWidgetT(mButtonType, mButtonSkin, IntCoord(), Align::Left | Align::Bottom);
button->eventMouseButtonClick = newDelegate(this, &Message::notifyButtonClick);
button->setCaption(_name);
button->_setInternalData(info);
mVectorButton.push_back(button);
updateSize();
return info;
}
void Canvas::setCoord(int _left, int _top, int _width, int _height)
{
setCoord(IntCoord(_left, _top, _width, _height));
}
void ItemBox::setCoord(int _left, int _top, int _width, int _height)
{
setCoord(IntCoord(_left, _top, _width, _height));
}
void Window::setCoord(int _left, int _top, int _width, int _height)
{
setCoord(IntCoord(_left, _top, _width, _height));
}
void RotatingSkin::_rebuildGeometry()
{
/*
0 1
3 2
*/
#ifndef M_PI
const float M_PI = 3.141593f;
#endif
float width_base = (float)mCurrentCoord.width;
float height_base = (float)mCurrentCoord.height;
// calculate original unrotated angles of uncropped rectangle verticies: between axis and line from center of rotation to vertex)
float baseAngles[RECT_VERTICIES_COUNT];
baseAngles[0] = atan2( (float)mCenterPos.left, (float)mCenterPos.top) + M_PI / 2;
baseAngles[1] = atan2( - width_base + (float)mCenterPos.left, (float)mCenterPos.top) + M_PI / 2;
baseAngles[2] = atan2( - width_base + (float)mCenterPos.left, - height_base + (float)mCenterPos.top) + M_PI / 2;
baseAngles[3] = atan2( (float)mCenterPos.left, - height_base + (float)mCenterPos.top) + M_PI / 2;
// calculate original unrotated distances of uncropped rectangle verticies: between center of rotation and vertex)
float baseDistances[RECT_VERTICIES_COUNT];
baseDistances[0] = len( (float)mCenterPos.left, (float)mCenterPos.top);
baseDistances[1] = len( - width_base + (float)mCenterPos.left, (float)mCenterPos.top);
baseDistances[2] = len( - width_base + (float)mCenterPos.left, - height_base + (float)mCenterPos.top);
baseDistances[3] = len( (float)mCenterPos.left, - height_base + (float)mCenterPos.top);
// calculate rotated positions of uncropped rectangle verticies (relative to parent)
FloatPoint baseVerticiesPos[RECT_VERTICIES_COUNT];
int offsetX = /*mCurrentCoord.left +*/ mCenterPos.left;
int offsetY = /*mCurrentCoord.top +*/ mCenterPos.top;
for (int i = 0; i < RECT_VERTICIES_COUNT; ++i)
{
baseVerticiesPos[i].left = offsetX + cos(-mAngle + baseAngles[i]) * baseDistances[i];
baseVerticiesPos[i].top = offsetY - sin(-mAngle + baseAngles[i]) * baseDistances[i];
}
// base texture coordinates
FloatPoint baseVerticiesUV[RECT_VERTICIES_COUNT] =
{
FloatPoint(mCurrentTexture.left, mCurrentTexture.top),
FloatPoint(mCurrentTexture.right, mCurrentTexture.top),
FloatPoint(mCurrentTexture.right, mCurrentTexture.bottom),
FloatPoint(mCurrentTexture.left, mCurrentTexture.bottom)
};
// now we have rotated uncropped rectangle verticies coordinates
// --------- here the cropping starts ---------
// now we are going to calculate verticies of resulting figure
// no parent - no cropping
size_t size = RECT_VERTICIES_COUNT;
if (nullptr == mCroppedParent->getCroppedParent())
{
for (int i = 0; i < RECT_VERTICIES_COUNT; ++i)
{
mResultVerticiesPos[i] = baseVerticiesPos[i];
mResultVerticiesUV[i] = baseVerticiesUV[i];
}
}
else
{
ICroppedRectangle* parent = mCroppedParent->getCroppedParent();
VectorFloatPoint resultVerticiesPos = geometry_utility::cropPolygon(
baseVerticiesPos,
RECT_VERTICIES_COUNT,
IntCoord(
parent->_getMarginLeft() - mCroppedParent->getLeft(),
parent->_getMarginTop() - mCroppedParent->getTop(),
parent->_getViewWidth(),
parent->_getViewHeight()
)
);
for (size_t i = 0; i < resultVerticiesPos.size(); ++i)
{
mResultVerticiesPos[i] = resultVerticiesPos[i];
}
size = resultVerticiesPos.size();
// calculate texture coordinates
FloatPoint v0 = baseVerticiesUV[3] - baseVerticiesUV[0];
FloatPoint v1 = baseVerticiesUV[1] - baseVerticiesUV[0];
for (size_t i = 0; i < GEOMETRY_VERTICIES_TOTAL_COUNT; ++i)
{
if (i < size)
{
FloatPoint point = geometry_utility::getPositionInsideRect(mResultVerticiesPos[i], baseVerticiesPos[0], baseVerticiesPos[1], baseVerticiesPos[3]);
mResultVerticiesUV[i] = geometry_utility::getUVFromPositionInsideRect(point, v0, v1, baseVerticiesUV[0]);
}
else
{
// all unused verticies is equal to last used
mResultVerticiesUV[i] = mResultVerticiesUV[size - 1];
}
}
}
// now calculate widget base offset and then resulting position in screen coordinates
const RenderTargetInfo& info = mRenderItem->getRenderTarget()->getInfo();
float vertex_left_base = ((info.pixScaleX * (float)(mCroppedParent->getAbsoluteLeft()) + info.hOffset) * 2) - 1;
float vertex_top_base = -(((info.pixScaleY * (float)(mCroppedParent->getAbsoluteTop()) + info.vOffset) * 2) - 1);
for (size_t i = 0; i < GEOMETRY_VERTICIES_TOTAL_COUNT; ++i)
{
if (i < size)
{
mResultVerticiesPos[i].left = vertex_left_base + mResultVerticiesPos[i].left * info.pixScaleX * 2;
mResultVerticiesPos[i].top = vertex_top_base + mResultVerticiesPos[i].top * info.pixScaleY * -2;
}
else
{
// all unused verticies is equal to last used
mResultVerticiesPos[i] = mResultVerticiesPos[size - 1];
}
}
}
