void ImagerySection::render(Window& srcWindow, const Rectf& baseRect, const CEGUI::ColourRect* modColours, const Rectf* clipper, bool clipToDisplay) const
{
// decide what to do as far as colours go
ColourRect finalCols;
initMasterColourRect(srcWindow, finalCols);
if (modColours)
finalCols *= *modColours;
ColourRect* finalColsPtr = (finalCols.isMonochromatic() && finalCols.d_top_left.getARGB() == 0xFFFFFFFF) ? 0 : &finalCols;
// render all frame components in this section
for(FrameList::const_iterator frame = d_frames.begin(); frame != d_frames.end(); ++frame)
{
(*frame).render(srcWindow, baseRect, finalColsPtr, clipper, clipToDisplay);
}
// render all image components in this section
for(ImageryList::const_iterator image = d_images.begin(); image != d_images.end(); ++image)
{
(*image).render(srcWindow, baseRect, finalColsPtr, clipper, clipToDisplay);
}
// render all text components in this section
for(TextList::const_iterator text = d_texts.begin(); text != d_texts.end(); ++text)
{
(*text).render(srcWindow, baseRect, finalColsPtr, clipper, clipToDisplay);
}
}
void FrameComponent::render_impl(Window& srcWindow, Rect& destRect, float base_z, const CEGUI::ColourRect* modColours, const Rect* clipper, bool clipToDisplay) const
{
Rect backgroundRect(destRect);
Rect finalRect;
Size imageSize;
ColourRect imageColours;
float leftfactor, rightfactor, topfactor, bottomfactor;
bool calcColoursPerImage;
// vars we use to track what to do with the side pieces.
float topOffset = 0, bottomOffset = 0, leftOffset = 0, rightOffset = 0;
float topWidth, bottomWidth, leftHeight, rightHeight;
topWidth = bottomWidth = destRect.getWidth();
leftHeight = rightHeight = destRect.getHeight();
// calculate final overall colours to be used
ColourRect finalColours;
initColoursRect(srcWindow, modColours, finalColours);
if (finalColours.isMonochromatic())
{
calcColoursPerImage = false;
imageColours = finalColours;
}
else
{
calcColoursPerImage = true;
}
// top-left image
if (d_frameImages[FIC_TOP_LEFT_CORNER])
{
// calculate final destination area
imageSize = d_frameImages[FIC_TOP_LEFT_CORNER]->getSize();
finalRect.d_left = destRect.d_left;
finalRect.d_top = destRect.d_top;
finalRect.setSize(imageSize);
// update adjustments required to edges do to presence of this element.
topOffset += imageSize.d_width;
leftOffset += imageSize.d_height;
topWidth -= topOffset;
leftHeight -= leftOffset;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_TOP_LEFT_CORNER]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_TOP_LEFT_CORNER]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_TOP_LEFT_CORNER], finalRect, base_z, imageColours, 0, clipToDisplay);
}
// top-right image
if (d_frameImages[FIC_TOP_RIGHT_CORNER])
{
// calculate final destination area
imageSize = d_frameImages[FIC_TOP_RIGHT_CORNER]->getSize();
finalRect.d_left = destRect.d_right - imageSize.d_width;
finalRect.d_top = destRect.d_top;
finalRect.setSize(imageSize);
// update adjustments required to edges do to presence of this element.
rightOffset += imageSize.d_height;
topWidth -= imageSize.d_width;
rightHeight -= rightOffset;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_TOP_RIGHT_CORNER]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_TOP_RIGHT_CORNER]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_TOP_RIGHT_CORNER], finalRect, base_z, imageColours, 0, clipToDisplay);
}
// bottom-left image
if (d_frameImages[FIC_BOTTOM_LEFT_CORNER])
{
// calculate final destination area
imageSize = d_frameImages[FIC_BOTTOM_LEFT_CORNER]->getSize();
finalRect.d_left = destRect.d_left;
finalRect.d_top = destRect.d_bottom - imageSize.d_height;
finalRect.setSize(imageSize);
// update adjustments required to edges do to presence of this element.
bottomOffset += imageSize.d_width;
bottomWidth -= bottomOffset;
leftHeight -= imageSize.d_height;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_BOTTOM_LEFT_CORNER]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_BOTTOM_LEFT_CORNER]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_BOTTOM_LEFT_CORNER], finalRect, base_z, imageColours, 0, clipToDisplay);
}
// bottom-right image
if (d_frameImages[FIC_BOTTOM_RIGHT_CORNER])
{
// calculate final destination area
imageSize = d_frameImages[FIC_BOTTOM_RIGHT_CORNER]->getSize();
finalRect.d_left = destRect.d_right - imageSize.d_width;
finalRect.d_top = destRect.d_bottom - imageSize.d_height;
finalRect.setSize(imageSize);
// update adjustments required to edges do to presence of this element.
bottomWidth -= imageSize.d_width;
rightHeight -= imageSize.d_height;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_BOTTOM_RIGHT_CORNER]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_BOTTOM_RIGHT_CORNER]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_BOTTOM_RIGHT_CORNER], finalRect, base_z, imageColours, 0, clipToDisplay);
}
// top image
if (d_frameImages[FIC_TOP_EDGE])
{
// calculate final destination area
imageSize = d_frameImages[FIC_TOP_EDGE]->getSize();
finalRect.d_left = destRect.d_left + topOffset;
finalRect.d_right = finalRect.d_left + topWidth;
finalRect.d_top = destRect.d_top;
finalRect.d_bottom = finalRect.d_top + imageSize.d_height;
// adjust background area to miss this edge
backgroundRect.d_top += imageSize.d_height + d_frameImages[FIC_TOP_EDGE]->getOffsetY();;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_TOP_EDGE]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_TOP_EDGE]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_TOP_EDGE], finalRect, base_z, imageColours, 0, clipToDisplay);
}
// bottom image
if (d_frameImages[FIC_BOTTOM_EDGE])
{
// calculate final destination area
imageSize = d_frameImages[FIC_BOTTOM_EDGE]->getSize();
finalRect.d_left = destRect.d_left + bottomOffset;
finalRect.d_right = finalRect.d_left + bottomWidth;
finalRect.d_bottom = destRect.d_bottom;
finalRect.d_top = finalRect.d_bottom - imageSize.d_height;
// adjust background area to miss this edge
backgroundRect.d_bottom -= imageSize.d_height - d_frameImages[FIC_BOTTOM_EDGE]->getOffsetY();;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_BOTTOM_EDGE]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_BOTTOM_EDGE]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_BOTTOM_EDGE], finalRect, base_z, imageColours, 0, clipToDisplay);
}
// left image
if (d_frameImages[FIC_LEFT_EDGE])
{
// calculate final destination area
imageSize = d_frameImages[FIC_LEFT_EDGE]->getSize();
finalRect.d_left = destRect.d_left;
finalRect.d_right = finalRect.d_left + imageSize.d_width;
finalRect.d_top = destRect.d_top + leftOffset;
finalRect.d_bottom = finalRect.d_top + leftHeight;
// adjust background area to miss this edge
backgroundRect.d_left += imageSize.d_width + d_frameImages[FIC_LEFT_EDGE]->getOffsetX();
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_LEFT_EDGE]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_LEFT_EDGE]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_LEFT_EDGE], finalRect, base_z, imageColours, 0, clipToDisplay);
}
// right image
if (d_frameImages[FIC_RIGHT_EDGE])
{
// calculate final destination area
imageSize = d_frameImages[FIC_RIGHT_EDGE]->getSize();
finalRect.d_top = destRect.d_top + rightOffset;
finalRect.d_bottom = finalRect.d_top + rightHeight;
finalRect.d_right = destRect.d_right;
finalRect.d_left = finalRect.d_right - imageSize.d_width;
// adjust background area to miss this edge
backgroundRect.d_right -= imageSize.d_width - d_frameImages[FIC_RIGHT_EDGE]->getOffsetX();
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.d_left + d_frameImages[FIC_RIGHT_EDGE]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.d_top + d_frameImages[FIC_RIGHT_EDGE]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_RIGHT_EDGE], finalRect, base_z, imageColours, 0, clipToDisplay);
}
if (d_frameImages[FIC_BACKGROUND])
{
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (backgroundRect.d_left + d_frameImages[FIC_BACKGROUND]->getOffsetX()) / destRect.getWidth();
rightfactor = leftfactor + backgroundRect.getWidth() / destRect.getWidth();
topfactor = (backgroundRect.d_top + d_frameImages[FIC_BACKGROUND]->getOffsetY()) / destRect.getHeight();
bottomfactor = topfactor + backgroundRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// render background image.
doBackgroundRender(srcWindow, backgroundRect, base_z, imageColours, clipper, clipToDisplay);
}
}
//----------------------------------------------------------------------------//
void FrameComponent::render_impl(Window& srcWindow, Rectf& destRect,
const CEGUI::ColourRect* modColours,
const Rectf* clipper, bool clipToDisplay) const
{
Rectf backgroundRect(destRect);
Rectf finalRect;
Sizef imageSize;
Vector2f imageOffsets;
ColourRect imageColours;
float leftfactor, rightfactor, topfactor, bottomfactor;
bool calcColoursPerImage;
// vars we use to track what to do with the side pieces.
float topOffset = 0, bottomOffset = 0, leftOffset = 0, rightOffset = 0;
float topWidth, bottomWidth, leftHeight, rightHeight;
topWidth = bottomWidth = destRect.getWidth();
leftHeight = rightHeight = destRect.getHeight();
// calculate final overall colours to be used
ColourRect finalColours;
initColoursRect(srcWindow, modColours, finalColours);
if (finalColours.isMonochromatic())
{
calcColoursPerImage = false;
imageColours = finalColours;
}
else
{
calcColoursPerImage = true;
}
// top-left image
if (const Image* const componentImage = getImage(FIC_TOP_LEFT_CORNER, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
imageOffsets = componentImage->getRenderedOffset();
finalRect.d_min = destRect.d_min;
finalRect.setSize(imageSize);
finalRect = destRect.getIntersection(finalRect);
// update adjustments required to edges do to presence of this element.
topOffset += imageSize.d_width + imageOffsets.d_x;
leftOffset += imageSize.d_height + imageOffsets.d_y;
topWidth -= topOffset;
leftHeight -= leftOffset;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + imageOffsets.d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + imageOffsets.d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
componentImage->render(srcWindow.getGeometryBuffer(), finalRect, clipper, imageColours);
}
// top-right image
if (const Image* const componentImage = getImage(FIC_TOP_RIGHT_CORNER, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
imageOffsets = componentImage->getRenderedOffset();
finalRect.left(destRect.right() - imageSize.d_width);
finalRect.top(destRect.top());
finalRect.setSize(imageSize);
finalRect = destRect.getIntersection(finalRect);
// update adjustments required to edges do to presence of this element.
rightOffset += imageSize.d_height + imageOffsets.d_y;
topWidth -= imageSize.d_width - imageOffsets.d_x;
rightHeight -= rightOffset;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + imageOffsets.d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + imageOffsets.d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle(leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
componentImage->render(srcWindow.getGeometryBuffer(), finalRect, clipper, imageColours);
}
// bottom-left image
if (const Image* const componentImage = getImage(FIC_BOTTOM_LEFT_CORNER, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
imageOffsets = componentImage->getRenderedOffset();
finalRect.left(destRect.left());
finalRect.top(destRect.bottom() - imageSize.d_height);
finalRect.setSize(imageSize);
finalRect = destRect.getIntersection(finalRect);
// update adjustments required to edges do to presence of this element.
bottomOffset += imageSize.d_width + imageOffsets.d_x;
bottomWidth -= bottomOffset;
leftHeight -= imageSize.d_height - imageOffsets.d_y;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + imageOffsets.d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + imageOffsets.d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle(leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
componentImage->render(srcWindow.getGeometryBuffer(), finalRect, clipper, imageColours);
}
// bottom-right image
if (const Image* const componentImage = getImage(FIC_BOTTOM_RIGHT_CORNER, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
imageOffsets = componentImage->getRenderedOffset();
finalRect.left(destRect.right() - imageSize.d_width);
finalRect.top(destRect.bottom() - imageSize.d_height);
finalRect.setSize(imageSize);
finalRect = destRect.getIntersection(finalRect);
// update adjustments required to edges do to presence of this element.
bottomWidth -= imageSize.d_width - imageOffsets.d_x;
rightHeight -= imageSize.d_height - imageOffsets.d_y;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + componentImage->getRenderedOffset().d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + componentImage->getRenderedOffset().d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
componentImage->render(srcWindow.getGeometryBuffer(), finalRect, clipper, imageColours);
}
// top image
if (const Image* const componentImage = getImage(FIC_TOP_EDGE, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
finalRect.left(destRect.left() + topOffset);
finalRect.right(finalRect.left() + topWidth);
finalRect.top(destRect.top());
finalRect.bottom(finalRect.top() + imageSize.d_height);
finalRect = destRect.getIntersection(finalRect);
// adjust background area to miss this edge
backgroundRect.d_min.d_y += imageSize.d_height + componentImage->getRenderedOffset().d_y;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + componentImage->getRenderedOffset().d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + componentImage->getRenderedOffset().d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
renderImage(srcWindow.getGeometryBuffer(), componentImage,
VF_TOP_ALIGNED, d_topEdgeFormatting.get(srcWindow),
finalRect, imageColours, clipper, clipToDisplay);
}
// bottom image
if (const Image* const componentImage = getImage(FIC_BOTTOM_EDGE, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
finalRect.left(destRect.left() + bottomOffset);
finalRect.right(finalRect.left() + bottomWidth);
finalRect.bottom(destRect.bottom());
finalRect.top(finalRect.bottom() - imageSize.d_height);
finalRect = destRect.getIntersection (finalRect);
// adjust background area to miss this edge
backgroundRect.d_max.d_y -= imageSize.d_height - componentImage->getRenderedOffset().d_y;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + componentImage->getRenderedOffset().d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + componentImage->getRenderedOffset().d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle(leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
renderImage(srcWindow.getGeometryBuffer(), componentImage,
VF_BOTTOM_ALIGNED, d_bottomEdgeFormatting.get(srcWindow),
finalRect, imageColours, clipper, clipToDisplay);
}
// left image
if (const Image* const componentImage = getImage(FIC_LEFT_EDGE, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
finalRect.left(destRect.left());
finalRect.right(finalRect.left() + imageSize.d_width);
finalRect.top(destRect.top() + leftOffset);
finalRect.bottom(finalRect.top() + leftHeight);
finalRect = destRect.getIntersection(finalRect);
// adjust background area to miss this edge
backgroundRect.d_min.d_x += imageSize.d_width + componentImage->getRenderedOffset().d_x;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + componentImage->getRenderedOffset().d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + componentImage->getRenderedOffset().d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
renderImage(srcWindow.getGeometryBuffer(), componentImage,
d_leftEdgeFormatting.get(srcWindow), HF_LEFT_ALIGNED,
finalRect, imageColours, clipper, clipToDisplay);
}
// right image
if (const Image* const componentImage = getImage(FIC_RIGHT_EDGE, srcWindow))
{
// calculate final destination area
imageSize = componentImage->getRenderedSize();
finalRect.top(destRect.top() + rightOffset);
finalRect.bottom(finalRect.top() + rightHeight);
finalRect.right(destRect.right());
finalRect.left(finalRect.right() - imageSize.d_width);
finalRect = destRect.getIntersection (finalRect);
// adjust background area to miss this edge
backgroundRect.d_max.d_x -= imageSize.d_width - componentImage->getRenderedOffset().d_x;
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (finalRect.left() + componentImage->getRenderedOffset().d_x) / destRect.getWidth();
rightfactor = leftfactor + finalRect.getWidth() / destRect.getWidth();
topfactor = (finalRect.top() + componentImage->getRenderedOffset().d_y) / destRect.getHeight();
bottomfactor = topfactor + finalRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
// draw this element.
renderImage(srcWindow.getGeometryBuffer(), componentImage,
d_rightEdgeFormatting.get(srcWindow), HF_RIGHT_ALIGNED,
finalRect, imageColours, clipper, clipToDisplay);
}
if (const Image* const componentImage = getImage(FIC_BACKGROUND, srcWindow))
{
// calculate colours that are to be used to this component image
if (calcColoursPerImage)
{
leftfactor = (backgroundRect.left() + componentImage->getRenderedOffset().d_x) / destRect.getWidth();
rightfactor = leftfactor + backgroundRect.getWidth() / destRect.getWidth();
topfactor = (backgroundRect.top() + componentImage->getRenderedOffset().d_y) / destRect.getHeight();
bottomfactor = topfactor + backgroundRect.getHeight() / destRect.getHeight();
imageColours = finalColours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
const HorizontalFormatting horzFormatting =
d_backgroundHorzFormatting.get(srcWindow);
const VerticalFormatting vertFormatting =
d_backgroundVertFormatting.get(srcWindow);
renderImage(srcWindow.getGeometryBuffer(), componentImage,
vertFormatting, horzFormatting,
backgroundRect, imageColours, clipper, clipToDisplay);
}
}
