bool ScriptEditorWindow::internal_isPointerHovering(ScriptEditorWindow* thisPtr)
{
if (!thisPtr->isDestroyed())
{
EditorWidgetBase* widget = thisPtr->getEditorWidget();
EditorWindowBase* window = widget->getParentWindow();
if (window == nullptr)
return false;
SPtr<RenderWindow> renderWindow = window->getRenderWindow();
Vector2I pointerPos = gInput().getPointerPosition();
if(Platform::isPointOverWindow(*renderWindow, pointerPos))
{
Rect2I bounds = thisPtr->getEditorWidget()->getBounds();
Vector2I widgetPos(bounds.x, bounds.y);
Vector2I screenPos = widget->widgetToScreenPos(widgetPos);
bounds.x = screenPos.x;
bounds.y = screenPos.y;
return bounds.contains(pointerPos);
}
}
return false;
}
Rect2I ScriptOSDropTarget::getDropTargetArea() const
{
Rect2I dropTargetArea = mArea;
dropTargetArea.x += mParentArea.x;
dropTargetArea.y += mParentArea.y;
dropTargetArea.clip(mParentArea);
return dropTargetArea;
}
void GUITabbedTitleBar::tabDragged(UINT32 tabIdx, const Vector2I& dragPos)
{
INT32 idx = uniqueIdxToSeqIdx(tabIdx);
if(idx != -1)
{
Rect2I bounds = _getLayoutData().area;
if(bounds.contains(dragPos))
{
if(!mDragInProgress)
startDrag(idx, dragPos);
mDragBtnOffset = dragPos.x - mInitialDragOffset;
for(INT32 i = 0; i < idx; i++)
{
UINT32 width = mTabButtons[i]->_getLayoutData().area.width;
INT32 centerX = mTabButtons[i]->_getLayoutData().area.x + width / 2;
if(dragPos.x < centerX)
{
GUITabButton* temp = mTabButtons[i];
mTabButtons[i] = mTabButtons[idx];
mTabButtons[idx] = temp;
break;
}
}
for(UINT32 i = idx + 1; i < (UINT32)mTabButtons.size(); i++)
{
UINT32 width = mTabButtons[i]->_getLayoutData().area.width;
INT32 centerX = mTabButtons[i]->_getLayoutData().area.x + width / 2;
if(dragPos.x > centerX)
{
GUITabButton* temp = mTabButtons[i];
mTabButtons[i] = mTabButtons[idx];
mTabButtons[idx] = temp;
break;
}
}
_markLayoutAsDirty();
}
else
{
endDrag();
_markLayoutAsDirty();
if(!onTabDraggedOff.empty())
onTabDraggedOff(tabIdx);
}
}
}
Rect2I Sprite::getBounds(const Vector2I& offset, const Rect2I& clipRect) const
{
Rect2I bounds = mBounds;
if(clipRect.width > 0 && clipRect.height > 0)
bounds.clip(clipRect);
bounds.x += offset.x;
bounds.y += offset.y;
return bounds;
}
ScissorRenderState* ScissorRenderState::Current()
{
IRender& render = Render::Instance();
ScissorRenderState* state = new ScissorRenderState();
state->Enable(render.GetBoolean(GraphicsBooleanName::ScissorTest));
Rect2I scissorBox;
render.GetIntegerArray(GraphicsIntegerArrayName::ScissorBox, scissorBox.GetBuffer());
state->SetScissorBox(Rect2F(scissorBox.Origin.X, scissorBox.Origin.Y, scissorBox.Size.Width, scissorBox.Size.Height));
return state;
}
bool GUIFloatField::_hasCustomCursor(const Vector2I position, CursorType& type) const
{
if (!_isDisabled())
{
Rect2I draggableArea;
if (mLabel != nullptr)
draggableArea = mLabel->_getLayoutData().area;
if (draggableArea.contains(position))
{
type = CursorType::ArrowLeftRight;
return true;
}
}
return false;
}
bool GUIFloatField::_mouseEvent(const GUIMouseEvent& event)
{
GUIElementContainer::_mouseEvent(event);
Rect2I draggableArea;
if(mLabel != nullptr)
draggableArea = mLabel->_getLayoutData().area;
if(event.getType() == GUIMouseEventType::MouseDragStart)
{
if (!_isDisabled())
{
if (draggableArea.contains(event.getDragStartPosition()))
{
mLastDragPos = event.getPosition().x;
mIsDragging = true;
}
}
return true;
}
else if(event.getType() == GUIMouseEventType::MouseDrag)
{
if (!_isDisabled())
{
if (mIsDragging)
{
INT32 xDiff = event.getPosition().x - mLastDragPos;
INT32 jumpAmount = 0;
Rect2I viewArea = _getParentWidget()->getTarget()->getPixelArea();
if (event.getPosition().x <= 0)
{
Vector2I cursorScreenPos = Cursor::instance().getScreenPosition();
jumpAmount = viewArea.width - event.getPosition().x - 1;
cursorScreenPos.x += jumpAmount;
Cursor::instance().setScreenPosition(cursorScreenPos);
}
else if (event.getPosition().x >= (INT32)viewArea.width)
{
Vector2I cursorScreenPos = Cursor::instance().getScreenPosition();
jumpAmount = -(INT32)viewArea.width - (event.getPosition().x - (INT32)viewArea.width) + 1;
cursorScreenPos.x += jumpAmount;
Cursor::instance().setScreenPosition(cursorScreenPos);
}
float oldValue = getValue();
float newValue = oldValue + xDiff * DRAG_SPEED;
mLastDragPos = event.getPosition().x + jumpAmount;
if (oldValue != newValue)
valueChanged(newValue);
}
}
return true;
}
else if(event.getType() == GUIMouseEventType::MouseDragEnd)
{
if (!_isDisabled())
mIsDragging = false;
return true;
}
return false;
}
void GUIScrollArea::_updateLayoutInternal(const GUILayoutData& data)
{
UINT32 numElements = (UINT32)mChildren.size();
Rect2I* elementAreas = nullptr;
if (numElements > 0)
elementAreas = bs_stack_new<Rect2I>(numElements);
UINT32 layoutIdx = 0;
UINT32 horzScrollIdx = 0;
UINT32 vertScrollIdx = 0;
for (UINT32 i = 0; i < numElements; i++)
{
GUIElementBase* child = _getChild(i);
if (child == mContentLayout)
layoutIdx = i;
if (child == mHorzScroll)
horzScrollIdx = i;
if (child == mVertScroll)
vertScrollIdx = i;
}
_getElementAreas(data.area, elementAreas, numElements, mChildSizeRanges, mVisibleSize, mContentSize);
Rect2I& layoutBounds = elementAreas[layoutIdx];
Rect2I& horzScrollBounds = elementAreas[horzScrollIdx];
Rect2I& vertScrollBounds = elementAreas[vertScrollIdx];
// Recalculate offsets in case scroll percent got updated externally (this needs to be delayed to this point because
// at the time of the update content and visible sizes might be out of date).
UINT32 scrollableHeight = (UINT32)std::max(0, INT32(mContentSize.y) - INT32(mVisibleSize.y));
if (mRecalculateVertOffset)
{
mVertOffset = scrollableHeight * Math::clamp01(mVertScroll->getScrollPos());
mRecalculateVertOffset = false;
}
UINT32 scrollableWidth = (UINT32)std::max(0, INT32(mContentSize.x) - INT32(mVisibleSize.x));
if (mRecalculateHorzOffset)
{
mHorzOffset = scrollableWidth * Math::clamp01(mHorzScroll->getScrollPos());
mRecalculateHorzOffset = false;
}
// Reset offset in case layout size changed so everything fits
mVertOffset = Math::clamp(mVertOffset, 0.0f, (float)scrollableHeight);
mHorzOffset = Math::clamp(mHorzOffset, 0.0f, (float)scrollableWidth);
// Layout
if (mContentLayout->_isActive())
{
layoutBounds.x -= Math::floorToInt(mHorzOffset);
layoutBounds.y -= Math::floorToInt(mVertOffset);
Rect2I layoutClipRect = data.clipRect;
layoutClipRect.width = (UINT32)mVisibleSize.x;
layoutClipRect.height = (UINT32)mVisibleSize.y;
layoutClipRect.clip(data.clipRect);
GUILayoutData layoutData = data;
layoutData.area = layoutBounds;
layoutData.clipRect = layoutClipRect;
mContentLayout->_setLayoutData(layoutData);
mContentLayout->_updateLayoutInternal(layoutData);
}
// Vertical scrollbar
{
GUILayoutData vertScrollData = data;
vertScrollData.area = vertScrollBounds;
vertScrollData.clipRect = vertScrollBounds;
vertScrollData.clipRect.clip(data.clipRect);
mVertScroll->_setLayoutData(vertScrollData);
mVertScroll->_updateLayoutInternal(vertScrollData);
// Set new handle size and update position to match the new size
UINT32 scrollableHeight = (UINT32)std::max(0, INT32(mContentSize.y) - INT32(vertScrollBounds.height));
float newScrollPct = 0.0f;
if (scrollableHeight > 0)
newScrollPct = mVertOffset / scrollableHeight;
mVertScroll->_setHandleSize(vertScrollBounds.height / (float)mContentSize.y);
mVertScroll->_setScrollPos(newScrollPct);
}
// Horizontal scrollbar
{
GUILayoutData horzScrollData = data;
horzScrollData.area = horzScrollBounds;
horzScrollData.clipRect = horzScrollBounds;
horzScrollData.clipRect.clip(data.clipRect);
mHorzScroll->_setLayoutData(horzScrollData);
mHorzScroll->_updateLayoutInternal(horzScrollData);
// Set new handle size and update position to match the new size
UINT32 scrollableWidth = (UINT32)std::max(0, INT32(mContentSize.x) - INT32(horzScrollBounds.width));
float newScrollPct = 0.0f;
if (scrollableWidth > 0)
newScrollPct = mHorzOffset / scrollableWidth;
mHorzScroll->_setHandleSize(horzScrollBounds.width / (float)mContentSize.x);
mHorzScroll->_setScrollPos(newScrollPct);
}
if (elementAreas != nullptr)
bs_stack_free(elementAreas);
}
bool GUIElement::_isInBounds(const Vector2I position) const
{
Rect2I contentBounds = getCachedVisibleBounds();
return contentBounds.contains(position);
}
bool GUIIntField::_mouseEvent(const GUIMouseEvent& event)
{
GUIElementContainer::_mouseEvent(event);
Rect2I draggableArea;
if(mLabel != nullptr)
draggableArea = mLabel->_getLayoutData().area;
if(event.getType() == GUIMouseEventType::MouseDragStart)
{
if (!_isDisabled())
{
if (draggableArea.contains(event.getDragStartPosition()))
{
mLastDragPos = event.getPosition().x;
mIsDragging = true;
}
}
return true;
}
else if(event.getType() == GUIMouseEventType::MouseDrag)
{
if (!_isDisabled())
{
if (mIsDragging)
{
INT32 xDiff = event.getPosition().x - mLastDragPos;
INT32 jumpAmount = 0;
if (event.getPosition().x < 0)
{
Vector2I cursorScreenPos = Cursor::instance().getScreenPosition();
cursorScreenPos.x += _getParentWidget()->getTarget()->getWidth();
jumpAmount = _getParentWidget()->getTarget()->getWidth();
Cursor::instance().setScreenPosition(cursorScreenPos);
}
else if (event.getPosition().x >= _getParentWidget()->getTarget()->getWidth())
{
Vector2I cursorScreenPos = Cursor::instance().getScreenPosition();
cursorScreenPos.x -= _getParentWidget()->getTarget()->getWidth();
jumpAmount = -_getParentWidget()->getTarget()->getWidth();
Cursor::instance().setScreenPosition(cursorScreenPos);
}
INT32 oldValue = getValue();
INT32 newValue = oldValue;
if (xDiff >= DRAG_SPEED)
{
while (xDiff >= DRAG_SPEED)
{
newValue++;
xDiff -= DRAG_SPEED;
}
}
else if (xDiff <= -DRAG_SPEED)
{
while (xDiff <= -DRAG_SPEED)
{
newValue--;
xDiff += DRAG_SPEED;
}
}
mLastDragPos += (newValue - oldValue) * DRAG_SPEED + jumpAmount;
if (oldValue != newValue)
valueChanged(newValue);
}
}
return true;
}
else if(event.getType() == GUIMouseEventType::MouseDragEnd)
{
if (!_isDisabled())
mIsDragging = false;
return true;
}
return false;
}
