void GUIButtonBase::updateRenderElementsInternal()
{
mImageDesc.width = mLayoutData.area.width;
mImageDesc.height = mLayoutData.area.height;
const HSpriteTexture& activeTex = getActiveTexture();
if (SpriteTexture::checkIsLoaded(activeTex))
mImageDesc.texture = activeTex.getInternalPtr();
else
mImageDesc.texture = nullptr;
mImageDesc.borderLeft = _getStyle()->border.left;
mImageDesc.borderRight = _getStyle()->border.right;
mImageDesc.borderTop = _getStyle()->border.top;
mImageDesc.borderBottom = _getStyle()->border.bottom;
mImageDesc.color = getTint();
mImageSprite->update(mImageDesc, (UINT64)_getParentWidget());
mTextSprite->update(getTextDesc(), (UINT64)_getParentWidget());
if(mContentImageSprite != nullptr)
{
Rect2I contentBounds = getCachedContentBounds();
HSpriteTexture image = mContent.getImage(mActiveState);
UINT32 contentWidth = image->getWidth();
UINT32 contentHeight = image->getHeight();
UINT32 contentMaxWidth = std::min((UINT32)contentBounds.width, contentWidth);
UINT32 contentMaxHeight = std::min((UINT32)contentBounds.height, contentHeight);
float horzRatio = contentMaxWidth / (float)contentWidth;
float vertRatio = contentMaxHeight / (float)contentHeight;
if (horzRatio < vertRatio)
{
contentWidth = Math::roundToInt(contentWidth * horzRatio);
contentHeight = Math::roundToInt(contentHeight * horzRatio);
}
else
{
contentWidth = Math::roundToInt(contentWidth * vertRatio);
contentHeight = Math::roundToInt(contentHeight * vertRatio);
}
IMAGE_SPRITE_DESC contentImgDesc;
contentImgDesc.texture = image.getInternalPtr();
contentImgDesc.width = contentWidth;
contentImgDesc.height = contentHeight;
contentImgDesc.color = getTint();
mContentImageSprite->update(contentImgDesc, (UINT64)_getParentWidget());
}
GUIElement::updateRenderElementsInternal();
}
void GUIScrollBar::updateRenderElementsInternal()
{
IMAGE_SPRITE_DESC desc;
if(_getStyle()->normal.texture != nullptr && _getStyle()->normal.texture.isLoaded())
desc.texture = _getStyle()->normal.texture.getInternalPtr();
desc.width = mLayoutData.area.width;
desc.height = mLayoutData.area.height;
desc.color = getTint();
mImageSprite->update(desc, (UINT64)_getParentWidget());
GUIElement::updateRenderElementsInternal();
}
void GUIWindowFrame::setFocused(bool focused)
{
Vector2I origSize = mDimensions.calculateSizeRange(_getOptimalSize()).optimal;
if(focused)
mActiveTexture = _getStyle()->focused.texture;
else
mActiveTexture = _getStyle()->normal.texture;
Vector2I newSize = mDimensions.calculateSizeRange(_getOptimalSize()).optimal;
if (origSize != newSize)
_markLayoutAsDirty();
else
_markContentAsDirty();
}
static const gchar * s_evalProperty (const PP_Property * pProp,
const PP_AttrProp * pAttrProp,
const PD_Document * pDoc,
bool bExpandStyles)
{
const gchar * szValue = NULL;
if (pAttrProp->getProperty (pProp->getName(), szValue))
{
return szValue;
}
if (!bExpandStyles) return NULL;
PD_Style * pStyle = _getStyle (pAttrProp, pDoc);
int i = 0;
while (pStyle && (i < pp_BASEDON_DEPTH_LIMIT))
{
if (pStyle->getProperty (pProp->getName (), szValue))
{
return szValue;
}
pStyle = pStyle->getBasedOn ();
i++;
}
return NULL;
}
TEXT_SPRITE_DESC GUIButtonBase::getTextDesc() const
{
TEXT_SPRITE_DESC textDesc;
textDesc.text = mContent.getText();
textDesc.font = _getStyle()->font;
textDesc.fontSize = _getStyle()->fontSize;
textDesc.color = getTint() * getActiveTextColor();
Rect2I textBounds = getCachedContentBounds();
textDesc.width = textBounds.width;
textDesc.height = textBounds.height;
textDesc.horzAlign = _getStyle()->textHorzAlign;
textDesc.vertAlign = _getStyle()->textVertAlign;
return textDesc;
}
Vector2I GUIButtonBase::_getOptimalSize() const
{
UINT32 imageWidth = 0;
UINT32 imageHeight = 0;
const HSpriteTexture& activeTex = getActiveTexture();
if(SpriteTexture::checkIsLoaded(activeTex))
{
imageWidth = activeTex->getWidth();
imageHeight = activeTex->getHeight();
}
Vector2I contentSize = GUIHelper::calcOptimalContentsSize(mContent, *_getStyle(), _getDimensions(), mActiveState);
UINT32 contentWidth = std::max(imageWidth, (UINT32)contentSize.x);
UINT32 contentHeight = std::max(imageHeight, (UINT32)contentSize.y);
return Vector2I(contentWidth, contentHeight);
}
Color GUIButtonBase::getActiveTextColor() const
{
switch (mActiveState)
{
case GUIElementState::Normal:
return _getStyle()->normal.textColor;
case GUIElementState::Hover:
return _getStyle()->hover.textColor;
case GUIElementState::Active:
return _getStyle()->active.textColor;
case GUIElementState::Focused:
return _getStyle()->focused.textColor;
case GUIElementState::NormalOn:
return _getStyle()->normalOn.textColor;
case GUIElementState::HoverOn:
return _getStyle()->hoverOn.textColor;
case GUIElementState::ActiveOn:
return _getStyle()->activeOn.textColor;
case GUIElementState::FocusedOn:
return _getStyle()->focusedOn.textColor;
}
return _getStyle()->normal.textColor;
}
/*
* call-seq:
* marshal_dump -> Array
*
* Provides marshalling support for use by the Marshal library.
* ===Return value
* Array
*/
DLL_LOCAL VALUE _marshal_dump(VALUE self)
{
VALUE ary = rb_ary_new();
rb_ary_push(ary,_getPointSize(self));
//rb_ary_push(ary,_getPixelSize(self));
rb_ary_push(ary,_getFamily(self));
rb_ary_push(ary,_getStyle(self));
rb_ary_push(ary,_getWeight(self));
rb_ary_push(ary,_getUnderlined(self));
rb_ary_push(ary,_getStrikethrough(self));
rb_ary_push(ary,_getFaceName(self));
#ifdef HAVE_RUBY_ENCODING_H
rb_ary_push(ary,_getEncoding(self));
#endif
return ary;
}
void GUIProgressBar::_updateLayoutInternal(const GUILayoutData& data)
{
mBackground->_setLayoutData(data);
const GUIElementStyle* style = _getStyle();
GUILayoutData barLayoutData = data;
barLayoutData.area.x += style->margins.left;
barLayoutData.area.y += style->margins.top;
UINT32 maxProgressBarWidth = std::max((UINT32)0, (UINT32)(data.area.width - style->margins.left - style->margins.right));
UINT32 progressBarHeight = std::max((UINT32)0, (UINT32)(data.area.height - style->margins.top - style->margins.bottom));
barLayoutData.area.width = (UINT32)Math::floorToInt(maxProgressBarWidth * mPercent);
barLayoutData.area.height = progressBarHeight;
mBar->_setLayoutData(barLayoutData);
}
void GUIButtonBase::_fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 vertexOffset, UINT32 indexOffset,
UINT32 maxNumVerts, UINT32 maxNumIndices, UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx) const
{
UINT32 textSpriteIdx = mImageSprite->getNumRenderElements();
UINT32 contentImgSpriteIdx = textSpriteIdx + mTextSprite->getNumRenderElements();
if(renderElementIdx < textSpriteIdx)
{
Vector2I offset(mLayoutData.area.x, mLayoutData.area.y);
mImageSprite->fillBuffer(vertices, uv, indices, vertexOffset, indexOffset, maxNumVerts, maxNumIndices,
vertexStride, indexStride, renderElementIdx, offset, mLayoutData.getLocalClipRect());
return;
}
Rect2I contentBounds = getCachedContentBounds();
Rect2I contentClipRect = getCachedContentClipRect();
Rect2I textBounds = mTextSprite->getBounds(Vector2I(), Rect2I());
Vector2I textOffset;
Rect2I textClipRect;
Vector2I imageOffset;
Rect2I imageClipRect;
if(mContentImageSprite != nullptr)
{
Rect2I imageBounds = mContentImageSprite->getBounds(Vector2I(), Rect2I());
INT32 imageXOffset = 0;
INT32 textImageSpacing = 0;
if (textBounds.width == 0)
{
UINT32 freeWidth = (UINT32)std::max(0, contentBounds.width - textBounds.width - imageBounds.width);
imageXOffset = (INT32)(freeWidth / 2);
}
else
textImageSpacing = GUIContent::IMAGE_TEXT_SPACING;
if(_getStyle()->imagePosition == GUIImagePosition::Right)
{
INT32 imageReservedWidth = std::max(0, contentBounds.width - textBounds.width);
textOffset = Vector2I(contentBounds.x, contentBounds.y);
textClipRect = contentClipRect;
textClipRect.width = std::min(contentBounds.width - imageReservedWidth, textClipRect.width);
imageOffset = Vector2I(contentBounds.x + textBounds.width + imageXOffset + textImageSpacing, contentBounds.y);
imageClipRect = contentClipRect;
imageClipRect.x -= textBounds.width + imageXOffset;
}
else
{
INT32 imageReservedWidth = imageBounds.width + imageXOffset;
imageOffset = Vector2I(contentBounds.x + imageXOffset, contentBounds.y);
imageClipRect = contentClipRect;
imageClipRect.x -= imageXOffset;
imageClipRect.width = std::min(imageReservedWidth, imageClipRect.width);
textOffset = Vector2I(contentBounds.x + imageReservedWidth + textImageSpacing, contentBounds.y);
textClipRect = contentClipRect;
textClipRect.x -= imageReservedWidth;
}
INT32 imageYOffset = (contentBounds.height - imageBounds.height) / 2;
imageClipRect.y -= imageYOffset;
imageOffset.y += imageYOffset;
}
else
{
textOffset = Vector2I(contentBounds.x, contentBounds.y);
textClipRect = contentClipRect;
}
if(renderElementIdx >= contentImgSpriteIdx)
{
mContentImageSprite->fillBuffer(vertices, uv, indices, vertexOffset, indexOffset, maxNumVerts, maxNumIndices,
vertexStride, indexStride, contentImgSpriteIdx - renderElementIdx, imageOffset, imageClipRect);
}
else
{
mTextSprite->fillBuffer(vertices, uv, indices, vertexOffset, indexOffset, maxNumVerts, maxNumIndices,
vertexStride, indexStride, textSpriteIdx - renderElementIdx, textOffset, textClipRect);
}
}
Vector2I GUIColor::_getOptimalSize() const
{
return GUIHelper::calcOptimalContentsSize(Vector2I(80, 10), *_getStyle(), _getDimensions()); // Arbitrary size
}
const PP_PropertyType * PP_evalPropertyType(const gchar * pszName,
const PP_AttrProp * pSpanAttrProp,
const PP_AttrProp * pBlockAttrProp,
const PP_AttrProp * pSectionAttrProp,
tProperty_type Type,
const PD_Document * pDoc,
bool bExpandStyles)
{
// find the value for the given property
// by evaluating it in the contexts given.
// use the CSS inheritance as necessary.
if (!pszName || !*pszName)
{
UT_DEBUGMSG(("PP_evalProperty: null property given\n"));
return NULL;
}
const PP_PropertyType * p_property;
const PP_Property * pProp = PP_lookupProperty(pszName);
if (!pProp)
{
UT_DEBUGMSG(("PP_evalProperty: unknown property \'%s\'\n",pszName));
return NULL;
}
PD_Style * pStyle = NULL;
// TODO: make lookup more efficient by tagging each property with scope (block, char, section)
// see if the property is on the Span item.
if (pSpanAttrProp)
{
p_property = pSpanAttrProp->getPropertyType(pProp->getName(), Type);
if(p_property)
return p_property;
if (bExpandStyles)
{
pStyle = _getStyle(pSpanAttrProp, pDoc);
int i = 0;
while (pStyle && (i < pp_BASEDON_DEPTH_LIMIT))
{
p_property = pStyle->getPropertyType(pProp->getName(), Type);
if(p_property)
return p_property;
pStyle = pStyle->getBasedOn();
i++;
}
}
}
// otherwise, see if we can inherit it from the containing block or the section.
if (!pSpanAttrProp || pProp->canInherit())
{
if (pBlockAttrProp)
{
p_property = pBlockAttrProp->getPropertyType(pProp->getName(), Type);
if(p_property)
return p_property;
if (bExpandStyles)
{
pStyle = _getStyle(pBlockAttrProp, pDoc);
int i = 0;
while (pStyle && (i < pp_BASEDON_DEPTH_LIMIT))
{
p_property = pStyle->getPropertyType(pProp->getName(), Type);
if(p_property)
return p_property;
pStyle = pStyle->getBasedOn();
i++;
}
}
}
if (!pBlockAttrProp || pProp->canInherit())
{
if (pSectionAttrProp)
{
p_property = pSectionAttrProp->getPropertyType(pProp->getName(), Type);
if(p_property)
return p_property;
}
}
}
if (pDoc->getStyle("Normal", &pStyle))
{
// next to last resort -- check for this property in the Normal style
p_property = pStyle->getPropertyType(pProp->getName(), Type);
if(p_property)
return p_property;
}
// if no inheritance allowed for it or there is no
// value set in containing block or section, we return
// the default value for this property.
return pProp->getInitialType(Type);
}
