/*************************************************************************
Processing for drag-sizing the segment
*************************************************************************/
void ListHeaderSegment::doDragSizing(const Point& local_mouse)
{
float delta = local_mouse.d_x - d_dragPoint.d_x;
// store this so we can work out how much size actually changed
float orgWidth = d_pixelSize.d_width;
// ensure that we only size to the set constraints.
//
// NB: We are required to do this here due to our virtually unique sizing nature; the
// normal system for limiting the window size is unable to supply the information we
// require for updating our internal state used to manage the dragging, etc.
float maxWidth(d_maxSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getDisplaySize().d_width));
float minWidth(d_minSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getDisplaySize().d_width));
float newWidth = orgWidth + delta;
if (newWidth > maxWidth)
delta = maxWidth - orgWidth;
else if (newWidth < minWidth)
delta = minWidth - orgWidth;
// update segment area rect
URect area(d_area.d_min.d_x, d_area.d_min.d_y, d_area.d_max.d_x + UDim(0,PixelAligned(delta)), d_area.d_max.d_y);
setArea_impl(area.d_min, area.getSize());
// move the dragging point so mouse remains 'attached' to edge of segment
d_dragPoint.d_x += d_pixelSize.d_width - orgWidth;
WindowEventArgs args(this);
onSegmentSized(args);
}
/*************************************************************************
Handler for mouse move events
*************************************************************************/
void FrameWindow::onMouseMove(MouseEventArgs& e)
{
// default processing (this is now essential as it controls event firing).
Window::onMouseMove(e);
// if we are not the window containing the mouse, do NOT change the cursor
if (getGUIContext().getWindowContainingMouse() != this)
{
return;
}
if (isSizingEnabled())
{
Vector2f localMousePos(CoordConverter::screenToWindow(*this, e.position));
if (d_beingSized)
{
SizingLocation dragEdge = getSizingBorderAtPoint(d_dragPoint);
// calculate sizing deltas...
float deltaX = localMousePos.d_x - d_dragPoint.d_x;
float deltaY = localMousePos.d_y - d_dragPoint.d_y;
URect new_area(d_area);
bool top_left_sizing = false;
// size left or right edges
if (isLeftSizingLocation(dragEdge))
{
top_left_sizing |= moveLeftEdge(deltaX, new_area);
}
else if (isRightSizingLocation(dragEdge))
{
top_left_sizing |= moveRightEdge(deltaX, new_area);
}
// size top or bottom edges
if (isTopSizingLocation(dragEdge))
{
top_left_sizing |= moveTopEdge(deltaY, new_area);
}
else if (isBottomSizingLocation(dragEdge))
{
top_left_sizing |= moveBottomEdge(deltaY, new_area);
}
setArea_impl(new_area.d_min, new_area.getSize(), top_left_sizing);
}
else
{
setCursorForPoint(localMousePos);
}
}
// mark event as handled
++e.handled;
}
/*************************************************************************
move the window's bottom edge by 'delta'. The rest of the window
does not move, thus this changes the size of the Window.
*************************************************************************/
void FrameWindow::moveBottomEdge(float delta)
{
// store this so we can work out how much size actually changed
float orgHeight = d_pixelSize.d_height;
URect area(d_area);
// ensure that we only size to the set constraints.
//
// NB: We are required to do this here due to our virtually unique sizing nature; the
// normal system for limiting the window size is unable to supply the information we
// require for updating our internal state used to manage the dragging, etc.
float maxHeight(d_maxSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight()));
float minHeight(d_minSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight()));
float newHeight = orgHeight + delta;
if (newHeight > maxHeight)
delta = maxHeight - orgHeight;
else if (newHeight < minHeight)
delta = minHeight - orgHeight;
// ensure adjustment will be whole pixel
float adjustment = PixelAligned(delta);
area.d_max.d_y.d_offset += adjustment;
if (d_vertAlign == VA_BOTTOM)
{
area.d_max.d_y.d_offset += adjustment;
area.d_min.d_y.d_offset += adjustment;
}
else if (d_vertAlign == VA_CENTRE)
{
area.d_max.d_y.d_offset += adjustment * 0.5f;
area.d_min.d_y.d_offset += adjustment * 0.5f;
}
setArea_impl(area.d_min, area.getSize(), d_vertAlign == VA_BOTTOM);
// move the dragging point so mouse remains 'attached' to edge of window
d_dragPoint.d_y += d_pixelSize.d_height - orgHeight;
}
/*************************************************************************
move the window's top edge by 'delta'. The rest of the window
does not move, thus this changes the size of the Window.
*************************************************************************/
void FrameWindow::moveTopEdge(float delta)
{
float orgHeight = d_pixelSize.d_height;
URect area(d_area);
// ensure that we only size to the set constraints.
//
// NB: We are required to do this here due to our virtually unique sizing nature; the
// normal system for limiting the window size is unable to supply the information we
// require for updating our internal state used to manage the dragging, etc.
float maxHeight(d_maxSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight()));
float minHeight(d_minSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight()));
float newHeight = orgHeight - delta;
if (newHeight > maxHeight)
delta = orgHeight - maxHeight;
else if (newHeight < minHeight)
delta = orgHeight - minHeight;
// ensure adjustment will be whole pixel
float adjustment = PixelAligned(delta);
if (d_vertAlign == VA_BOTTOM)
{
area.d_max.d_y.d_offset -= adjustment;
}
else if (d_vertAlign == VA_CENTRE)
{
area.d_max.d_y.d_offset -= adjustment * 0.5f;
area.d_min.d_y.d_offset += adjustment * 0.5f;
}
else
{
area.d_min.d_y.d_offset += adjustment;
}
setArea_impl(area.d_min, area.getSize(), d_vertAlign == VA_TOP);
}
/*************************************************************************
move the window's left edge by 'delta'. The rest of the window
does not move, thus this changes the size of the Window.
*************************************************************************/
void FrameWindow::moveLeftEdge(float delta)
{
float orgWidth = d_pixelSize.d_width;
URect area(d_area);
// ensure that we only size to the set constraints.
//
// NB: We are required to do this here due to our virtually unique sizing nature; the
// normal system for limiting the window size is unable to supply the information we
// require for updating our internal state used to manage the dragging, etc.
float maxWidth(d_maxSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getWidth()));
float minWidth(d_minSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getWidth()));
float newWidth = orgWidth - delta;
if (newWidth > maxWidth)
delta = orgWidth - maxWidth;
else if (newWidth < minWidth)
delta = orgWidth - minWidth;
// ensure adjustment will be whole pixel
float adjustment = PixelAligned(delta);
if (d_horzAlign == HA_RIGHT)
{
area.d_max.d_x.d_offset -= adjustment;
}
else if (d_horzAlign == HA_CENTRE)
{
area.d_max.d_x.d_offset -= adjustment * 0.5f;
area.d_min.d_x.d_offset += adjustment * 0.5f;
}
else
{
area.d_min.d_x.d_offset += adjustment;
}
setArea_impl(area.d_min, area.getSize(), d_horzAlign == HA_LEFT);
}
