/*************************************************************************
Move the window by the pixel offsets specified in 'offset'.
*************************************************************************/
void FrameWindow::offsetPixelPosition(const Vector2& offset)
{
UVector2 uOffset(cegui_absdim(PixelAligned(offset.d_x)),
cegui_absdim(PixelAligned(offset.d_y)));
setPosition(d_area.getPosition() + uOffset);
}
//----------------------------------------------------------------------------//
void OpenGLGeometryBuffer::setClippingRegion(const Rect& region)
{
d_clipRect.d_top = ceguimax(0.0f, PixelAligned(region.d_top));
d_clipRect.d_bottom = ceguimax(0.0f, PixelAligned(region.d_bottom));
d_clipRect.d_left = ceguimax(0.0f, PixelAligned(region.d_left));
d_clipRect.d_right = ceguimax(0.0f, PixelAligned(region.d_right));
}
//----------------------------------------------------------------------------//
void Direct3D8GeometryBuffer::setClippingRegion(const Rect& region)
{
d_clipRect.d_top = PixelAligned(region.d_top);
d_clipRect.d_bottom = PixelAligned(region.d_bottom);
d_clipRect.d_left = PixelAligned(region.d_left);
d_clipRect.d_right = PixelAligned(region.d_right);
}
/*************************************************************************
Sets up sizes and positions for attached ItemEntry children.
*************************************************************************/
void Menubar::layoutItemWidgets()
{
Rect render_rect = getItemRenderArea();
float x0 = PixelAligned(render_rect.d_left+d_borderWidth);
Rect rect;
ItemEntryList::iterator item = d_listItems.begin();
while ( item != d_listItems.end() )
{
Size optimal = (*item)->getItemPixelSize();
optimal.d_width += 2*d_horzPadding;
optimal.d_height += 2*d_vertPadding;
(*item)->setVerticalAlignment(VA_CENTRE);
rect.setPosition( Point(x0,0) );
rect.setSize( Size( PixelAligned(optimal.d_width), PixelAligned(optimal.d_height) ) );
(*item)->setRect(Absolute,rect);
x0 += optimal.d_width + d_itemSpacing;
item++;
}
}
/*************************************************************************
Queues an area of the associated Texture the be drawn on the screen.
Low-level routine not normally used!
*************************************************************************/
void Imageset::draw(const Rect& source_rect, const Rect& dest_rect, float z, const Rect& clip_rect,const ColourRect& colours, QuadSplitMode quad_split_mode, const Image* image ) const
{
// get the rect area that we will actually draw to (i.e. perform clipping)
Rect final_rect(dest_rect.getIntersection(clip_rect));
// check if rect was totally clipped
if (final_rect.getWidth() != 0)
{
float x_scale = 1.0f / (float)d_texture->getWidth();
float y_scale = 1.0f / (float)d_texture->getHeight();
float tex_per_pix_x = source_rect.getWidth() / dest_rect.getWidth();
float tex_per_pix_y = source_rect.getHeight() / dest_rect.getHeight();
// calculate final, clipped, texture co-ordinates
Rect tex_rect((source_rect.d_left + ((final_rect.d_left - dest_rect.d_left) * tex_per_pix_x)) * x_scale,
(source_rect.d_top + ((final_rect.d_top - dest_rect.d_top) * tex_per_pix_y)) * y_scale,
(source_rect.d_right + ((final_rect.d_right - dest_rect.d_right) * tex_per_pix_x)) * x_scale,
(source_rect.d_bottom + ((final_rect.d_bottom - dest_rect.d_bottom) * tex_per_pix_y)) * y_scale);
final_rect.d_left = PixelAligned(final_rect.d_left);
final_rect.d_right = PixelAligned(final_rect.d_right);
final_rect.d_top = PixelAligned(final_rect.d_top);
final_rect.d_bottom = PixelAligned(final_rect.d_bottom);
// queue a quad to be rendered
d_texture->getRenderer()->addQuad(final_rect, z, d_texture, tex_rect, colours, quad_split_mode,image);
}
}
/*************************************************************************
Sets up sizes and positions for attached ItemEntry children.
*************************************************************************/
void PopupMenu::layoutItemWidgets()
{
// get render area
Rect render_rect = getItemRenderArea();
// get starting position
const float x0 = PixelAligned(render_rect.d_left);
float y0 = PixelAligned(render_rect.d_top);
URect rect;
UVector2 sz(cegui_absdim(PixelAligned(render_rect.getWidth())), cegui_absdim(0)); // set item width
// iterate through all items attached to this window
ItemEntryList::iterator item = d_listItems.begin();
while ( item != d_listItems.end() )
{
// get the "optimal" height of the item and use that!
sz.d_y.d_offset = PixelAligned((*item)->getItemPixelSize().d_height); // rounding errors ?
// set destination rect
rect.setPosition(UVector2(cegui_absdim(x0), cegui_absdim(y0)) );
rect.setSize( sz );
(*item)->setArea(rect);
// next position
y0 += PixelAligned(sz.d_y.d_offset + d_itemSpacing);
item++; // next item
}
}
/*************************************************************************
Return the rendered pixel size of this list box item.
*************************************************************************/
Size ListboxWrappedTextItem::getPixelSize(void) const
{
Size size(0,0);
if (d_owner != NULL)
{
size.d_width = d_owner->getPixelSize().d_width - 25.0f;
}
Font* font = const_cast<Font*>(getFont());
if (font != NULL)
{
size.d_height = PixelAligned(font->getLineSpacing());
if(size.d_width == 0)
{
size.d_width = PixelAligned(font->getTextExtent(d_itemText));
}
Rect formatRect;
formatRect.setPosition(CEGUI::Point(0,0));
if (d_draw_bullet)
{
formatRect.d_left = font->getTextExtent(ds_bullet);
}
formatRect.setSize(size);
uint lines = font->getFormattedLineCount(d_itemText, formatRect, d_textFormatting);
size.d_height *= lines;
size.d_height += d_padding;
}
return size;
}
//----------------------------------------------------------------------------//
void RenderingWindow::setSize(const Size& size)
{
d_size.d_width = PixelAligned(size.d_width);
d_size.d_height = PixelAligned(size.d_height);
d_geometryValid = false;
d_textarget.declareRenderSize(d_size);
}
void FalagardProgressBarEx::render()
{
const StateImagery* imagery;
// get WidgetLookFeel for the assigned look.
const WidgetLookFeel& wlf = getLookNFeel();
// try and get imagery for our current state
imagery = &wlf.getStateImagery(d_window->isDisabled() ? "Disabled" : "Enabled");
// peform the rendering operation.
imagery->render(*d_window);
// get imagery for actual progress rendering
imagery = &wlf.getStateImagery(d_window->isDisabled() ? "DisabledProgress" : "EnabledProgress");
// get target rect for this imagery
Rect progressRect(wlf.getNamedArea("ProgressArea").getArea().getPixelRect(*d_window));
// calculate a clipper according to the current progress.
Rect progressClipper(progressRect);
ProgressBar* w = (ProgressBar*)d_window;
if (d_vertical)
{
float height = PixelAligned(progressClipper.getHeight() * w->getProgress());
if (d_reversed)
{
progressClipper.setHeight(height);
}
else
{
progressClipper.d_top = progressClipper.d_bottom - height;
}
}
else
{
float width = PixelAligned(progressClipper.getWidth() * w->getProgress());
if (d_reversed)
{
progressClipper.d_left = progressClipper.d_right - width;
}
else
{
progressClipper.setWidth(width);
}
}
// peform the rendering operation.
imagery->render(*d_window, progressRect, 0, &progressClipper);
// perform the text rendering operation
imagery = &wlf.getStateImagery("Label");
imagery->render(*d_window);
}
/*************************************************************************
Return the rendered pixel size of this list box item.
*************************************************************************/
Size ListboxNumberItem::getPixelSize(void) const
{
Size tmp(0,0);
const Font* fnt = getFont();
if (fnt != NULL)
{
tmp.d_height = PixelAligned(fnt->getLineSpacing());
tmp.d_width = PixelAligned(fnt->getTextExtent(d_itemText));
}
return tmp;
}
/*************************************************************************
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);
}
/*************************************************************************
Draw the list box item in its current state.
*************************************************************************/
void ListboxTextItem::draw(GeometryBuffer& buffer, const Rect& targetRect,
float alpha, const Rect* clipper) const
{
if (d_selected && d_selectBrush != 0)
d_selectBrush->draw(buffer, targetRect, clipper,
getModulateAlphaColourRect(d_selectCols, alpha));
Font* font = getFont();
if (!font)
return;
Vector2 draw_pos(targetRect.getPosition());
draw_pos.d_y += PixelAligned(
(font->getLineSpacing() - font->getFontHeight()) * 0.5f);
if (!d_renderedStringValid)
parseTextString();
const ColourRect final_colours(
getModulateAlphaColourRect(ColourRect(0xFFFFFFFF), alpha));
for (size_t i = 0; i < d_renderedString.getLineCount(); ++i)
{
d_renderedString.draw(i, buffer, draw_pos, &final_colours, clipper, 0.0f);
draw_pos.d_y += d_renderedString.getPixelSize(i).d_height;
}
}
/*************************************************************************
Draw the list box item in its current state.
*************************************************************************/
void ListboxWrappedTextItem::draw(const Vector3& position, float alpha, const Rect& clipper) const
{
if (d_selected && (d_selectBrush != 0))
{
d_selectBrush->draw(clipper, position.d_z, clipper,
getModulateAlphaColourRect(d_selectCols, alpha));
}
Font* font = const_cast<Font*>(getFont());
if (font)
{
float left_offset = 0;
if (d_draw_bullet)
{
left_offset = font->getTextExtent(ds_bullet);
}
Vector3 finalPos = position;
finalPos.d_y -= PixelAligned((font->getLineSpacing() - font->getBaseline()) * 0.5f);
Rect draw_area = Rect(finalPos.d_x, finalPos.d_y,
clipper.d_right, finalPos.d_y);
font->drawText(ds_bullet, draw_area, finalPos.d_z, clipper, d_textFormatting,
getModulateAlphaColourRect(d_textCols, alpha));
draw_area.d_left += left_offset;
font->drawText(d_itemText, draw_area, finalPos.d_z, clipper, d_textFormatting,
getModulateAlphaColourRect(d_textCols, alpha));
}
}
void PushButton::resizeWithText()
{
Size size = getRenderSize();
setSize( Absolute, size );
Point newPos;
newPos.d_x = m_ptHookPosition.d_x;
newPos.d_y = m_ptHookPosition.d_y;
switch( m_HookMode )
{
case Hook_Left:
newPos.d_y -= d_pixelSize.d_height / 2;
break;
case Hook_Right:
newPos.d_x -= d_pixelSize.d_width;
newPos.d_y -= d_pixelSize.d_height / 2;
break;
case Hook_Top:
newPos.d_x -= d_pixelSize.d_width / 2;
break;
case Hook_Bottom:
newPos.d_x -= d_pixelSize.d_width / 2;
newPos.d_y -= d_pixelSize.d_height;
break;
case Hook_LeftTop:
break;
case Hook_LeftBottom:
newPos.d_y -= d_pixelSize.d_height;
break;
case Hook_RightTop:
newPos.d_x -= d_pixelSize.d_width;
break;
case Hook_RightBottom:
newPos.d_x -= d_pixelSize.d_width;
newPos.d_y -= d_pixelSize.d_height;
break;
case Hook_Center:
newPos.d_x -= d_pixelSize.d_width / 2;
newPos.d_y -= d_pixelSize.d_height / 2;
break;
default:
break;
}
UVector2 relativePos;
d_area.setPosition( UVector2(cegui_absdim(PixelAligned(newPos.d_x)), cegui_absdim(PixelAligned( newPos.d_y) ) ) );
}
/*************************************************************************
Return the rendered pixel size of this list box item.
*************************************************************************/
Size ListboxImageItem::getPixelSize(void)
{
if ( !d_bSizeChanged )
return d_savedPixelSize;
Size tmp(0,0);
if (d_image != NULL)
{
tmp.d_height = PixelAligned(d_image->getHeight());
tmp.d_width = PixelAligned(d_image->getWidth());
}
d_bSizeChanged = false;
d_savedPixelSize = tmp;
return tmp;
}
/*************************************************************************
Return the rendered pixel size of this list box item.
*************************************************************************/
Size ListboxTextItem::getPixelSize(void)
{
if ( !d_bSizeChanged )
return d_savedPixelSize;
Size tmp(0,0);
const Font* fnt = getFont();
if (fnt != NULL)
{
tmp.d_height = PixelAligned(fnt->getLineSpacing());
tmp.d_width = PixelAligned(fnt->getTextExtent(d_itemText));
}
d_bSizeChanged = false;
d_savedPixelSize = tmp;
return tmp;
}
/*************************************************************************
Sets up sizes and positions for attached ItemEntry children.
*************************************************************************/
void Menubar::layoutItemWidgets()
{
Rect render_rect = getItemRenderArea();
float x0 = PixelAligned(render_rect.d_left);
URect rect;
ItemEntryList::iterator item = d_listItems.begin();
while ( item != d_listItems.end() )
{
const Size optimal = (*item)->getItemPixelSize();
(*item)->setVerticalAlignment(VA_CENTRE);
rect.setPosition(UVector2(cegui_absdim(x0), cegui_absdim(0)) );
rect.setSize( UVector2( cegui_absdim(PixelAligned(optimal.d_width)),
cegui_absdim(PixelAligned(optimal.d_height))));
(*item)->setArea(rect);
x0 += optimal.d_width + d_itemSpacing;
++item;
}
}
void ListboxTextItem::draw(RenderCache& cache,const Rect& targetRect, float zBase, float alpha, const Rect* clipper) const
{
if (d_selected && d_selectBrush != 0)
{
cache.cacheImage(*d_selectBrush, targetRect, zBase, getModulateAlphaColourRect(d_selectCols, alpha), clipper);
}
Font* font = getFont();
if (font)
{
Rect finalPos(targetRect);
finalPos.d_top += PixelAligned((font->getLineSpacing() - font->getFontHeight()) * 0.5f);
cache.cacheText(d_itemText, font, LeftAligned, finalPos, zBase, getModulateAlphaColourRect(d_textCols, alpha), clipper);
}
}
void ListboxTextItem::draw(RenderCache& cache,const Rect& targetRect, float zBase, float alpha, const Rect* clipper) const
{
if (d_selected && d_selectBrush != 0)
{
cache.cacheImage(*d_selectBrush, targetRect, zBase, getModulateAlphaColourRect(d_selectCols, alpha), clipper);
}
const FontBase* font = getFont();
if (font)
{
Rect finalPos(targetRect);
finalPos.d_top += PixelAligned( FontBase::LineSpace * 0.5f);
cache.cacheText( getOwnerWindow(), d_itemText, font, d_horzFormateing, finalPos, zBase, getModulateAlphaColourRect(d_textCols, alpha), clipper);
}
}
/*************************************************************************
Draw the list box item in its current state.
*************************************************************************/
void ListboxNumberItem::draw(const Vector3& position, float alpha, const Rect& clipper) const
{
if (d_selected && (d_selectBrush != NULL))
{
d_selectBrush->draw(clipper, position.d_z, clipper, getModulateAlphaColourRect(d_selectCols, alpha));
}
const Font* fnt = getFont();
if (fnt != NULL)
{
Vector3 finalPos(position);
finalPos.d_y -= PixelAligned((fnt->getLineSpacing() - fnt->getBaseline()) * 0.5f);
fnt->drawText(d_itemText, finalPos, clipper, getModulateAlphaColourRect(d_textCols, alpha));
}
}
/*************************************************************************
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);
}
/*************************************************************************
set the vertical scaling factor to be applied to this Image
*************************************************************************/
void Image::setVertScaling(float factor)
{
d_scaledHeight = PixelAligned(d_area.getHeight() * factor);
d_scaledOffset.d_y = PixelAligned(d_offset.d_y * factor);
}
/*************************************************************************
set the horizontal scaling factor to be applied to this Image
*************************************************************************/
void Image::setHorzScaling(float factor)
{
d_scaledWidth = PixelAligned(d_area.getWidth() * factor);
d_scaledOffset.d_x = PixelAligned(d_offset.d_x * factor);
}
void CPFRotatingText::renderRotatingText()
{
Font* font = d_window->getFont();
// can't render text without a font :)
if( font==NULL){
return;
}
// get destination area for the text.
Rect absarea(getTextRenderArea());
Rect clipper(absarea);
float textHeight = font->getFormattedLineCount(d_window->getText(), absarea, (TextFormatting)d_horzFormatting) * font->getLineSpacing();
Scrollbar* vertScrollbar = getVertScrollbar();
Scrollbar* horzScrollbar = getHorzScrollbar();
// calculate X offset
static float xOffset = horzScrollbar->getPageSize();
if( xOffset<-(horzScrollbar->getDocumentSize()+horzScrollbar->getPageSize()) ){
xOffset = horzScrollbar->getPageSize();
}
static boost::system_time previous_time = boost::get_system_time();
boost::system_time time = boost::get_system_time();
boost::system_time::time_duration_type time_step = (time-previous_time);
xOffset -= (static_cast<float>(time_step.total_milliseconds())*d_textSpeed);
previous_time = time;
absarea.offset(Point(xOffset, 0));
// see if we may need to adjust horizontal position
if( horzScrollbar->isVisible() ){
switch(d_horzFormatting)
{
case LeftAligned:
case WordWrapLeftAligned:
case Justified:
case WordWrapJustified:
absarea.offset(Point(-horzScrollbar->getScrollPosition(), 0));
break;
case Centred:
case WordWrapCentred:
absarea.setWidth(horzScrollbar->getDocumentSize());
absarea.offset(Point(-horzScrollbar->getScrollPosition(), 0));
break;
case RightAligned:
case WordWrapRightAligned:
absarea.offset(Point(horzScrollbar->getScrollPosition(), 0));
break;
}
}
// adjust y positioning according to formatting option
switch(d_vertFormatting)
{
case TopAligned:
absarea.d_top -= vertScrollbar->getScrollPosition();
break;
case VertCentred:
// if scroll bar is in use, act like TopAligned
if( vertScrollbar->isVisible() ){
absarea.d_top -= vertScrollbar->getScrollPosition();
}
// no scroll bar, so centre text instead.
else{
absarea.d_top += PixelAligned((absarea.getHeight() - textHeight) * 0.5f);
}
break;
case BottomAligned:
absarea.d_top = absarea.d_bottom - textHeight;
absarea.d_top += vertScrollbar->getScrollPosition();
break;
}
// offset the font little down so that it's centered within its own spacing
absarea.d_top += (font->getLineSpacing() - font->getFontHeight()) * 0.5f;
// calculate final colours
ColourRect final_cols(d_textCols);
final_cols.modulateAlpha(d_window->getEffectiveAlpha());
// cache the text for rendering.
d_window->getRenderCache().cacheText(d_window->getText(), font, (TextFormatting)d_horzFormatting, absarea, 0, final_cols, &clipper);
}
/*************************************************************************
Renders text on the display. Return number of lines output.
*************************************************************************/
size_t Font::drawText(const String& text, const Rect& draw_area, float z, const Rect& clip_rect, TextFormatting fmt, const ColourRect& colours, float x_scale, float y_scale)
{
size_t thisCount;
size_t lineCount = 0;
float y_base = draw_area.d_top + getBaseline(y_scale);
Rect tmpDrawArea(
PixelAligned(draw_area.d_left),
PixelAligned(draw_area.d_top),
PixelAligned(draw_area.d_right),
PixelAligned(draw_area.d_bottom)
);
size_t lineStart = 0, lineEnd = 0;
String currLine;
while (lineEnd < text.length())
{
if ((lineEnd = text.find_first_of('\n', lineStart)) == String::npos)
lineEnd = text.length();
currLine = text.substr(lineStart, lineEnd - lineStart);
lineStart = lineEnd + 1; // +1 to skip \n char
switch(fmt)
{
case LeftAligned:
drawTextLine(currLine, Vector3(tmpDrawArea.d_left, y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case RightAligned:
drawTextLine(currLine, Vector3(tmpDrawArea.d_right - getTextExtent(currLine, x_scale), y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case Centred:
drawTextLine(currLine, Vector3(PixelAligned(tmpDrawArea.d_left + ((tmpDrawArea.getWidth() - getTextExtent(currLine, x_scale)) / 2.0f)), y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case Justified:
// new function in order to keep drawTextLine's signature unchanged
drawTextLineJustified(currLine, draw_area, Vector3(tmpDrawArea.d_left, y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case WordWrapLeftAligned:
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, LeftAligned, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
case WordWrapRightAligned:
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, RightAligned, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
case WordWrapCentred:
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, Centred, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
case WordWrapJustified:
// no change needed
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, Justified, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
default:
throw InvalidRequestException("Font::drawText - Unknown or unsupported TextFormatting value specified.");
}
lineCount += thisCount;
}
// should not return 0
return ceguimax(lineCount, (size_t)1);
}
void ImageryComponent::render_impl(Window& srcWindow, Rect& destRect, float base_z, const CEGUI::ColourRect* modColours, const Rect* clipper, bool clipToDisplay) const
{
// get final image to use.
const Image* img = isImageFetchedFromProperty() ?
PropertyHelper::stringToImage(srcWindow.getProperty(d_imagePropertyName)) :
d_image;
// do not draw anything if image is not set.
if (!img)
return;
HorizontalFormatting horzFormatting = d_horzFormatPropertyName.empty() ? d_horzFormatting :
FalagardXMLHelper::stringToHorzFormat(srcWindow.getProperty(d_horzFormatPropertyName));
VerticalFormatting vertFormatting = d_vertFormatPropertyName.empty() ? d_vertFormatting :
FalagardXMLHelper::stringToVertFormat(srcWindow.getProperty(d_vertFormatPropertyName));
uint horzTiles, vertTiles;
float xpos, ypos;
Size imgSz(img->getSize());
// calculate final colours to be used
ColourRect finalColours;
initColoursRect(srcWindow, modColours, finalColours);
// calculate initial x co-ordinate and horizontal tile count according to formatting options
switch (horzFormatting)
{
case HF_STRETCHED:
imgSz.d_width = destRect.getWidth();
xpos = destRect.d_left;
horzTiles = 1;
break;
case HF_TILED:
xpos = destRect.d_left;
horzTiles = (uint)((destRect.getWidth() + (imgSz.d_width - 1)) / imgSz.d_width);
break;
case HF_LEFT_ALIGNED:
xpos = destRect.d_left;
horzTiles = 1;
break;
case HF_CENTRE_ALIGNED:
xpos = destRect.d_left + PixelAligned((destRect.getWidth() - imgSz.d_width) * 0.5f);
horzTiles = 1;
break;
case HF_RIGHT_ALIGNED:
xpos = destRect.d_right - imgSz.d_width;
horzTiles = 1;
break;
default:
throw InvalidRequestException("ImageryComponent::render - An unknown HorizontalFormatting value was specified.");
}
// calculate initial y co-ordinate and vertical tile count according to formatting options
switch (vertFormatting)
{
case VF_STRETCHED:
imgSz.d_height = destRect.getHeight();
ypos = destRect.d_top;
vertTiles = 1;
break;
case VF_TILED:
ypos = destRect.d_top;
vertTiles = (uint)((destRect.getHeight() + (imgSz.d_height - 1)) / imgSz.d_height);
break;
case VF_TOP_ALIGNED:
ypos = destRect.d_top;
vertTiles = 1;
break;
case VF_CENTRE_ALIGNED:
ypos = destRect.d_top + PixelAligned((destRect.getHeight() - imgSz.d_height) * 0.5f);
vertTiles = 1;
break;
case VF_BOTTOM_ALIGNED:
ypos = destRect.d_bottom - imgSz.d_height;
vertTiles = 1;
break;
default:
throw InvalidRequestException("ImageryComponent::render - An unknown VerticalFormatting value was specified.");
}
// perform final rendering (actually is now a caching of the images which will be drawn)
Rect finalRect;
Rect finalClipper;
const Rect* clippingRect;
finalRect.d_top = ypos;
finalRect.d_bottom = ypos + imgSz.d_height;
for (uint row = 0; row < vertTiles; ++row)
{
finalRect.d_left = xpos;
finalRect.d_right = xpos + imgSz.d_width;
for (uint col = 0; col < horzTiles; ++col)
{
// use custom clipping for right and bottom edges when tiling the imagery
if (((vertFormatting == VF_TILED) && row == vertTiles - 1) ||
((horzFormatting == HF_TILED) && col == horzTiles - 1))
{
finalClipper = clipper ? clipper->getIntersection(destRect) : destRect;
clippingRect = &finalClipper;
}
// not tiliing, or not on far edges, just used passed in clipper (if any).
else
{
clippingRect = clipper;
}
// add image to the rendering cache for the target window.
srcWindow.getRenderCache().cacheImage(*img, finalRect, base_z, finalColours, clippingRect, clipToDisplay);
finalRect.d_left += imgSz.d_width;
finalRect.d_right += imgSz.d_width;
}
finalRect.d_top += imgSz.d_height;
finalRect.d_bottom += imgSz.d_height;
}
}
/*************************************************************************
Queues an area of the associated Texture the be drawn on the screen.
Low-level routine not normally used!
*************************************************************************/
void Imageset::draw(GeometryBuffer& buffer, const Rect& source_rect,
const Rect& dest_rect, const Rect* clip_rect,const ColourRect& colours,
QuadSplitMode quad_split_mode) const
{
// get the rect area that we will actually draw to (i.e. perform clipping)
Rect final_rect(clip_rect ? dest_rect.getIntersection(*clip_rect) : dest_rect );
// check if rect was totally clipped
if ((final_rect.getWidth() == 0) || (final_rect.getHeight() == 0))
return;
// Fix bug #45
// Obtain correct scale values from the texture
const float x_scale = d_texture->getTexelScaling().d_x;
const float y_scale = d_texture->getTexelScaling().d_y;
float tex_per_pix_x = source_rect.getWidth() / dest_rect.getWidth();
float tex_per_pix_y = source_rect.getHeight() / dest_rect.getHeight();
// calculate final, clipped, texture co-ordinates
Rect tex_rect((source_rect.d_left + ((final_rect.d_left - dest_rect.d_left) * tex_per_pix_x)) * x_scale,
(source_rect.d_top + ((final_rect.d_top - dest_rect.d_top) * tex_per_pix_y)) * y_scale,
(source_rect.d_right + ((final_rect.d_right - dest_rect.d_right) * tex_per_pix_x)) * x_scale,
(source_rect.d_bottom + ((final_rect.d_bottom - dest_rect.d_bottom) * tex_per_pix_y)) * y_scale);
final_rect.d_left = PixelAligned(final_rect.d_left);
final_rect.d_right = PixelAligned(final_rect.d_right);
final_rect.d_top = PixelAligned(final_rect.d_top);
final_rect.d_bottom = PixelAligned(final_rect.d_bottom);
Vertex vbuffer[6];
// vertex 0
vbuffer[0].position = Vector3(final_rect.d_left, final_rect.d_top, 0.0f);
vbuffer[0].colour_val = colours.d_top_left;
vbuffer[0].tex_coords = Vector2(tex_rect.d_left, tex_rect.d_top);
// vertex 1
vbuffer[1].position = Vector3(final_rect.d_left, final_rect.d_bottom, 0.0f);
vbuffer[1].colour_val = colours.d_bottom_left;
vbuffer[1].tex_coords = Vector2(tex_rect.d_left, tex_rect.d_bottom);
// vertex 2
vbuffer[2].position.d_x = final_rect.d_right;
vbuffer[2].position.d_z = 0.0f;
vbuffer[2].colour_val = colours.d_bottom_right;
vbuffer[2].tex_coords.d_x = tex_rect.d_right;
// top-left to bottom-right diagonal
if (quad_split_mode == TopLeftToBottomRight)
{
vbuffer[2].position.d_y = final_rect.d_bottom;
vbuffer[2].tex_coords.d_y = tex_rect.d_bottom;
}
// bottom-left to top-right diagonal
else
{
vbuffer[2].position.d_y = final_rect.d_top;
vbuffer[2].tex_coords.d_y = tex_rect.d_top;
}
// vertex 3
vbuffer[3].position = Vector3(final_rect.d_right, final_rect.d_top, 0.0f);
vbuffer[3].colour_val = colours.d_top_right;
vbuffer[3].tex_coords = Vector2(tex_rect.d_right, tex_rect.d_top);
// vertex 4
vbuffer[4].position.d_x = final_rect.d_left;
vbuffer[4].position.d_z = 0.0f;
vbuffer[4].colour_val = colours.d_top_left;
vbuffer[4].tex_coords.d_x = tex_rect.d_left;
// top-left to bottom-right diagonal
if (quad_split_mode == TopLeftToBottomRight)
{
vbuffer[4].position.d_y = final_rect.d_top;
vbuffer[4].tex_coords.d_y = tex_rect.d_top;
}
// bottom-left to top-right diagonal
else
{
vbuffer[4].position.d_y = final_rect.d_bottom;
vbuffer[4].tex_coords.d_y = tex_rect.d_bottom;
}
// vertex 5
vbuffer[5].position = Vector3(final_rect.d_right, final_rect.d_bottom, 0.0f);
vbuffer[5].colour_val= colours.d_bottom_right;
vbuffer[5].tex_coords = Vector2(tex_rect.d_right, tex_rect.d_bottom);
// TODO: Remove cast when GeometryBuffer gets it's APIs fixed!
buffer.setActiveTexture((Texture*)d_texture);
buffer.appendGeometry(vbuffer, 6);
}
void FrameComponent::doBackgroundRender(Window& srcWindow, Rect& destRect, const ColourRect& colours, const Rect* clipper, bool /*clipToDisplay*/) const
{
HorizontalFormatting horzFormatting = d_horzFormatPropertyName.empty() ? d_horzFormatting :
FalagardXMLHelper::stringToHorzFormat(srcWindow.getProperty(d_horzFormatPropertyName));
VerticalFormatting vertFormatting = d_vertFormatPropertyName.empty() ? d_vertFormatting :
FalagardXMLHelper::stringToVertFormat(srcWindow.getProperty(d_vertFormatPropertyName));
uint horzTiles, vertTiles;
float xpos, ypos;
Size imgSz(d_frameImages[FIC_BACKGROUND]->getSize());
// calculate initial x co-ordinate and horizontal tile count according to formatting options
switch (horzFormatting)
{
case HF_STRETCHED:
imgSz.d_width = destRect.getWidth();
xpos = destRect.d_left;
horzTiles = 1;
break;
case HF_TILED:
xpos = destRect.d_left;
horzTiles = std::abs(static_cast<int>(
(destRect.getWidth() + (imgSz.d_width - 1)) / imgSz.d_width));
break;
case HF_LEFT_ALIGNED:
xpos = destRect.d_left;
horzTiles = 1;
break;
case HF_CENTRE_ALIGNED:
xpos = destRect.d_left + PixelAligned((destRect.getWidth() - imgSz.d_width) * 0.5f);
horzTiles = 1;
break;
case HF_RIGHT_ALIGNED:
xpos = destRect.d_right - imgSz.d_width;
horzTiles = 1;
break;
default:
CEGUI_THROW(InvalidRequestException("FrameComponent::doBackgroundRender - An unknown HorizontalFormatting value was specified."));
}
// calculate initial y co-ordinate and vertical tile count according to formatting options
switch (vertFormatting)
{
case VF_STRETCHED:
imgSz.d_height = destRect.getHeight();
ypos = destRect.d_top;
vertTiles = 1;
break;
case VF_TILED:
ypos = destRect.d_top;
vertTiles = std::abs(static_cast<int>(
(destRect.getHeight() + (imgSz.d_height - 1)) / imgSz.d_height));
break;
case VF_TOP_ALIGNED:
ypos = destRect.d_top;
vertTiles = 1;
break;
case VF_CENTRE_ALIGNED:
ypos = destRect.d_top + PixelAligned((destRect.getHeight() - imgSz.d_height) * 0.5f);
vertTiles = 1;
break;
case VF_BOTTOM_ALIGNED:
ypos = destRect.d_bottom - imgSz.d_height;
vertTiles = 1;
break;
default:
CEGUI_THROW(InvalidRequestException("FrameComponent::doBackgroundRender - An unknown VerticalFormatting value was specified."));
}
// perform final rendering (actually is now a caching of the images which will be drawn)
Rect finalRect;
Rect finalClipper;
const Rect* clippingRect;
finalRect.d_top = ypos;
finalRect.d_bottom = ypos + imgSz.d_height;
for (uint row = 0; row < vertTiles; ++row)
{
finalRect.d_left = xpos;
finalRect.d_right = xpos + imgSz.d_width;
for (uint col = 0; col < horzTiles; ++col)
{
// use custom clipping for right and bottom edges when tiling the imagery
if (((vertFormatting == VF_TILED) && row == vertTiles - 1) ||
((horzFormatting == HF_TILED) && col == horzTiles - 1))
{
finalClipper = clipper ? clipper->getIntersection(destRect) : destRect;
clippingRect = &finalClipper;
}
// not tiliing, or not on far edges, just used passed in clipper (if any).
else
{
clippingRect = clipper;
}
// add image to the rendering cache for the target window.
d_frameImages[FIC_BACKGROUND]->draw(srcWindow.getGeometryBuffer(), finalRect, clippingRect, colours);
finalRect.d_left += imgSz.d_width;
finalRect.d_right += imgSz.d_width;
}
finalRect.d_top += imgSz.d_height;
finalRect.d_bottom += imgSz.d_height;
}
}