GUISlider::GUISlider(xml_node<>* node)
{
xml_attribute<>* attr;
xml_node<>* child;
sAction = NULL;
sSlider = NULL;
sSliderUsed = NULL;
sTouch = NULL;
sTouchW = 20;
if (!node)
{
LOGE("GUISlider created without XML node\n");
return;
}
child = node->first_node("resource");
if (child)
{
attr = child->first_attribute("base");
if (attr)
sSlider = PageManager::FindResource(attr->value());
attr = child->first_attribute("used");
if (attr)
sSliderUsed = PageManager::FindResource(attr->value());
attr = child->first_attribute("touch");
if (attr)
sTouch = PageManager::FindResource(attr->value());
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY);
if (sSlider && sSlider->GetResource())
{
mRenderW = gr_get_width(sSlider->GetResource());
mRenderH = gr_get_height(sSlider->GetResource());
}
if (sTouch && sTouch->GetResource())
{
sTouchW = gr_get_width(sTouch->GetResource()); // Width of the "touch image" that follows the touch (arrow)
sTouchH = gr_get_height(sTouch->GetResource()); // Height of the "touch image" that follows the touch (arrow)
}
//LOGI("mRenderW: %i mTouchW: %i\n", mRenderW, mTouchW);
mActionX = mRenderX;
mActionY = mRenderY;
mActionW = mRenderW;
mActionH = mRenderH;
sAction = new GUIAction(node);
sCurTouchX = mRenderX;
sUpdate = 1;
return;
}
GUIText::GUIText(xml_node<>* node)
: Conditional(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mFont = NULL;
mIsStatic = 1;
mVarChanged = 0;
mFontHeight = 0;
maxWidth = 0;
charSkip = 0;
if (!node) return;
// Initialize color to solid black
memset(&mColor, 0, sizeof(COLOR));
mColor.alpha = 255;
attr = node->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mColor);
}
// Load the font, and possibly override the color
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mFont = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mColor);
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH, &mPlacement);
child = node->first_node("text");
if (child) mText = child->value();
// Simple way to check for static state
mLastValue = parseText();
if (mLastValue != mText) mIsStatic = 0;
gr_getFontDetails(mFont ? mFont->GetResource() : NULL, (unsigned*) &mFontHeight, NULL);
return;
}
GUIConsole::GUIConsole(xml_node<>* node) : GUIScrollList(node)
{
xml_node<>* child;
mLastCount = 0;
scrollToEnd = true;
mSlideoutX = mSlideoutY = mSlideoutW = mSlideoutH = 0;
mSlideout = 0;
mSlideoutState = visible;
allowSelection = false; // console doesn't support list item selections
if (!node)
{
mRenderX = 0; mRenderY = 0; mRenderW = gr_fb_width(); mRenderH = gr_fb_height();
}
else
{
child = FindNode(node, "color");
if (child)
{
mFontColor = LoadAttrColor(child, "foreground", mFontColor);
mBackgroundColor = LoadAttrColor(child, "background", mBackgroundColor);
//mScrollColor = LoadAttrColor(child, "scroll", mScrollColor);
}
child = FindNode(node, "slideout");
if (child)
{
mSlideout = 1;
mSlideoutState = hidden;
LoadPlacement(child, &mSlideoutX, &mSlideoutY, &mSlideoutW, &mSlideoutH, &mPlacement);
mSlideoutImage = LoadAttrImage(child, "resource");
if (mSlideoutImage && mSlideoutImage->GetResource())
{
mSlideoutW = mSlideoutImage->GetWidth();
mSlideoutH = mSlideoutImage->GetHeight();
if (mPlacement == CENTER || mPlacement == CENTER_X_ONLY) {
mSlideoutX = mSlideoutX - (mSlideoutW / 2);
if (mPlacement == CENTER) {
mSlideoutY = mSlideoutY - (mSlideoutH / 2);
}
}
}
}
}
}
GUIProgressBar::GUIProgressBar(xml_node<>* node) : GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mEmptyBar = NULL;
mFullBar = NULL;
mLastPos = 0;
mSlide = 0.0;
mSlideInc = 0.0;
if (!node)
{
LOGERR("GUIProgressBar created without XML node\n");
return;
}
child = FindNode(node, "resource");
if (child)
{
mEmptyBar = LoadAttrImage(child, "empty");
mFullBar = LoadAttrImage(child, "full");
}
// Load the placement
LoadPlacement(FindNode(node, "placement"), &mRenderX, &mRenderY);
// Load the data
child = FindNode(node, "data");
if (child)
{
mMinValVar = LoadAttrString(child, "min");
mMaxValVar = LoadAttrString(child, "max");
mCurValVar = LoadAttrString(child, "name");
}
mRenderW = mEmptyBar->GetWidth();
mRenderH = mEmptyBar->GetHeight();
}
GUIFill::GUIFill(xml_node<>* node)
{
xml_attribute<>* attr;
xml_node<>* child;
if (!node)
return;
attr = node->first_attribute("color");
if (!attr) {
LOGERR("No color specified for fill\n");
return;
}
std::string color = attr->value();
ConvertStrToColor(color, &mColor);
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH);
return;
}
GUIPartitionList::GUIPartitionList(xml_node<>* node) : GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
int header_separator_color_specified = 0, header_separator_height_specified = 0, header_text_color_specified = 0, header_background_color_specified = 0;
mStart = mLineSpacing = startY = mFontHeight = mSeparatorH = scrollingY = scrollingSpeed = 0;
mIconWidth = mIconHeight = mSelectedIconHeight = mSelectedIconWidth = mUnselectedIconHeight = mUnselectedIconWidth = mHeaderIconHeight = mHeaderIconWidth = 0;
mHeaderSeparatorH = mLineHeight = mHeaderIsStatic = mHeaderH = actualLineHeight = 0;
mIconSelected = mIconUnselected = mBackground = mFont = mHeaderIcon = NULL;
mBackgroundX = mBackgroundY = mBackgroundW = mBackgroundH = 0;
mFastScrollW = mFastScrollLineW = mFastScrollRectW = mFastScrollRectH = 0;
mFastScrollRectX = mFastScrollRectY = -1;
mUpdate = 0;
touchDebounce = 6;
ConvertStrToColor("black", &mBackgroundColor);
ConvertStrToColor("black", &mHeaderBackgroundColor);
ConvertStrToColor("black", &mSeparatorColor);
ConvertStrToColor("black", &mHeaderSeparatorColor);
ConvertStrToColor("white", &mFontColor);
ConvertStrToColor("white", &mHeaderFontColor);
ConvertStrToColor("white", &mFastScrollLineColor);
ConvertStrToColor("white", &mFastScrollRectColor);
hasHighlightColor = false;
hasFontHighlightColor = false;
isHighlighted = false;
updateList = false;
startSelection = -1;
// Load header text
child = node->first_node("header");
if (child)
{
attr = child->first_attribute("icon");
if (attr)
mHeaderIcon = PageManager::FindResource(attr->value());
attr = child->first_attribute("background");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderBackgroundColor);
header_background_color_specified = -1;
}
attr = child->first_attribute("textcolor");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderFontColor);
header_text_color_specified = -1;
}
attr = child->first_attribute("separatorcolor");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderSeparatorColor);
header_separator_color_specified = -1;
}
attr = child->first_attribute("separatorheight");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mHeaderSeparatorH = atoi(parsevalue.c_str());
header_separator_height_specified = -1;
}
}
child = node->first_node("text");
if (child) mHeaderText = child->value();
memset(&mHighlightColor, 0, sizeof(COLOR));
child = node->first_node("highlight");
if (child) {
attr = child->first_attribute("color");
if (attr) {
hasHighlightColor = true;
std::string color = attr->value();
ConvertStrToColor(color, &mHighlightColor);
}
}
// Simple way to check for static state
mLastValue = gui_parse_text(mHeaderText);
if (mLastValue != mHeaderText)
mHeaderIsStatic = 0;
else
mHeaderIsStatic = -1;
child = node->first_node("icon");
if (child)
{
attr = child->first_attribute("selected");
if (attr)
mIconSelected = PageManager::FindResource(attr->value());
attr = child->first_attribute("unselected");
if (attr)
mIconUnselected = PageManager::FindResource(attr->value());
}
child = node->first_node("background");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mBackground = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mBackgroundColor);
if (!header_background_color_specified)
ConvertStrToColor(color, &mHeaderBackgroundColor);
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
// Load the font, and possibly override the color
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mFont = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mFontColor);
if (!header_text_color_specified)
ConvertStrToColor(color, &mHeaderFontColor);
}
attr = child->first_attribute("spacing");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mLineSpacing = atoi(parsevalue.c_str());
}
attr = child->first_attribute("highlightcolor");
memset(&mFontHighlightColor, 0, sizeof(COLOR));
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mFontHighlightColor);
hasFontHighlightColor = true;
}
}
// Load the separator if it exists
child = node->first_node("separator");
if (child)
{
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mSeparatorColor);
if (!header_separator_color_specified)
ConvertStrToColor(color, &mHeaderSeparatorColor);
}
attr = child->first_attribute("height");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mSeparatorH = atoi(parsevalue.c_str());
if (!header_separator_height_specified)
mHeaderSeparatorH = mSeparatorH;
}
}
// Handle the result variable
child = node->first_node("data");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mVariable = attr->value();
attr = child->first_attribute("selectedlist");
if (attr)
selectedList = attr->value();
}
// Fast scroll colors
child = node->first_node("fastscroll");
if (child)
{
attr = child->first_attribute("linecolor");
if(attr)
ConvertStrToColor(attr->value(), &mFastScrollLineColor);
attr = child->first_attribute("rectcolor");
if(attr)
ConvertStrToColor(attr->value(), &mFastScrollRectColor);
attr = child->first_attribute("w");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollW = atoi(parsevalue.c_str());
}
attr = child->first_attribute("linew");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollLineW = atoi(parsevalue.c_str());
}
attr = child->first_attribute("rectw");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollRectW = atoi(parsevalue.c_str());
}
attr = child->first_attribute("recth");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollRectH = atoi(parsevalue.c_str());
}
}
// Retrieve the line height
gr_getFontDetails(mFont ? mFont->GetResource() : NULL, &mFontHeight, NULL);
mLineHeight = mFontHeight;
mHeaderH = mFontHeight;
if (mIconSelected && mIconSelected->GetResource())
{
mSelectedIconWidth = gr_get_width(mIconSelected->GetResource());
mSelectedIconHeight = gr_get_height(mIconSelected->GetResource());
if (mSelectedIconHeight > (int)mLineHeight)
mLineHeight = mSelectedIconHeight;
mIconWidth = mSelectedIconWidth;
}
if (mIconUnselected && mIconUnselected->GetResource())
{
mUnselectedIconWidth = gr_get_width(mIconUnselected->GetResource());
mUnselectedIconHeight = gr_get_height(mIconUnselected->GetResource());
if (mUnselectedIconHeight > (int)mLineHeight)
mLineHeight = mUnselectedIconHeight;
if (mUnselectedIconWidth > mIconWidth)
mIconWidth = mUnselectedIconWidth;
}
if (mHeaderIcon && mHeaderIcon->GetResource())
{
mHeaderIconWidth = gr_get_width(mHeaderIcon->GetResource());
mHeaderIconHeight = gr_get_height(mHeaderIcon->GetResource());
if (mHeaderIconHeight > mHeaderH)
mHeaderH = mHeaderIconHeight;
if (mHeaderIconWidth > mIconWidth)
mIconWidth = mHeaderIconWidth;
}
mHeaderH += mLineSpacing + mHeaderSeparatorH;
actualLineHeight = mLineHeight + mLineSpacing + mSeparatorH;
if (mHeaderH < actualLineHeight)
mHeaderH = actualLineHeight;
if (actualLineHeight / 3 > 6)
touchDebounce = actualLineHeight / 3;
if (mBackground && mBackground->GetResource())
{
mBackgroundW = gr_get_width(mBackground->GetResource());
mBackgroundH = gr_get_height(mBackground->GetResource());
}
child = node->first_node("listtype");
if (child) {
attr = child->first_attribute("name");
if (attr) {
ListType = attr->value();
PartitionManager.Get_Partition_List(ListType, &mList);
} else {
mList.clear();
LOGERR("No partition listtype name specified for partitionlist GUI element\n");
return;
}
} else {
mList.clear();
LOGERR("No partition listtype specified for partitionlist GUI element\n");
return;
}
}
GUIInput::GUIInput(xml_node<>* node)
: GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mInputText = NULL;
mAction = NULL;
mBackground = NULL;
mCursor = NULL;
mFont = NULL;
mRendered = false;
HasMask = false;
DrawCursor = false;
isLocalChange = true;
HasAllowed = false;
HasDisabled = false;
skipChars = scrollingX = mFontHeight = mFontY = lastX = 0;
mBackgroundX = mBackgroundY = mBackgroundW = mBackgroundH = MinLen = MaxLen = 0;
mCursorLocation = -1; // -1 is always the end of the string
CursorWidth = 3;
ConvertStrToColor("black", &mBackgroundColor);
ConvertStrToColor("white", &mCursorColor);
if (!node)
return;
// Load text directly from the node
mInputText = new GUIText(node);
// Load action directly from the node
mAction = new GUIAction(node);
if (mInputText->Render() < 0)
{
delete mInputText;
mInputText = NULL;
}
// Load the background
child = FindNode(node, "background");
if (child)
{
mBackground = LoadAttrImage(child, "resource");
mBackgroundColor = LoadAttrColor(child, "color", mBackgroundColor);
}
if (mBackground && mBackground->GetResource())
{
mBackgroundW = mBackground->GetWidth();
mBackgroundH = mBackground->GetHeight();
}
// Load the cursor color
child = FindNode(node, "cursor");
if (child)
{
mCursor = LoadAttrImage(child, "resource");
mCursorColor = LoadAttrColor(child, "color", mCursorColor);
attr = child->first_attribute("hasfocus");
if (attr)
{
std::string focus = attr->value();
SetInputFocus(atoi(focus.c_str()));
}
CursorWidth = LoadAttrIntScaleX(child, "width", CursorWidth);
}
DrawCursor = HasInputFocus;
// Load the font
child = FindNode(node, "font");
if (child)
{
mFont = LoadAttrFont(child, "resource");
mFontHeight = mFont->GetHeight();
}
child = FindNode(node, "text");
if (child) mText = child->value();
mLastValue = gui_parse_text(mText);
child = FindNode(node, "data");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mVariable = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mVariable, attr->value());
mMask = LoadAttrString(child, "mask");
HasMask = !mMask.empty();
attr = child->first_attribute("maskvariable");
if (attr)
mMaskVariable = attr->value();
else
mMaskVariable = mVariable;
}
// Load input restrictions
child = FindNode(node, "restrict");
if (child)
{
MinLen = LoadAttrInt(child, "minlen", MinLen);
MaxLen = LoadAttrInt(child, "maxlen", MaxLen);
AllowedList = LoadAttrString(child, "allow");
HasAllowed = !AllowedList.empty();
DisabledList = LoadAttrString(child, "disable");
HasDisabled = !DisabledList.empty();
}
// Load the placement
LoadPlacement(FindNode(node, "placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
if (mInputText && mFontHeight && mFontHeight < (unsigned)mRenderH) {
mFontY = ((mRenderH - mFontHeight) / 2) + mRenderY;
mInputText->SetRenderPos(mRenderX, mFontY);
} else
mFontY = mRenderY;
if (mInputText)
mInputText->SetMaxWidth(mRenderW);
isLocalChange = false;
HandleTextLocation(-3);
}
GUISliderValue::GUISliderValue(xml_node<>* node) : GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mMin = 0;
mMax = 100;
mValue = 0;
mLineH = 2;
mLinePadding = 10;
mSliderW = 5;
mSliderH = 30;
mLineX = 0;
mLineY = 0;
mValueStr = NULL;
mAction = NULL;
mShowCurr = true;
mShowRange = false;
mChangeOnDrag = false;
mRendered = false;
mLabel = NULL;
ConvertStrToColor("white", &mTextColor);
ConvertStrToColor("white", &mLineColor);
ConvertStrToColor("blue", &mSliderColor);
if (!node)
{
LOGERR("GUISliderValue created without XML node\n");
return;
}
mLabel = new GUIText(node);
if(mLabel->Render() < 0)
{
delete mLabel;
mLabel = NULL;
}
mAction = new GUIAction(node);
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mFont = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mTextColor);
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW);
child = node->first_node("colors");
if (child)
{
attr = child->first_attribute("line");
if (attr)
ConvertStrToColor(attr->value(), &mLineColor);
attr = child->first_attribute("slider");
if (attr)
ConvertStrToColor(attr->value(), &mSliderColor);
}
child = node->first_node("data");
if (child)
{
attr = child->first_attribute("variable");
if (attr)
mVariable = attr->value();
attr = child->first_attribute("min");
if (attr)
{
mMinStr = gui_parse_text(attr->value());
mMin = atoi(mMinStr.c_str());
}
attr = child->first_attribute("max");
if (attr)
{
mMaxStr = gui_parse_text(attr->value());
mMax = atoi(mMaxStr.c_str());
}
if (mMin > mMax)
mMin = mMax;
attr = child->first_attribute("default");
if (attr)
{
string parsevalue = gui_parse_text(attr->value());
int def = atoi(parsevalue.c_str());
if (def < mMin) def = mMin;
else if (def > mMax) def = mMax;
DataManager::SetValue(mVariable, def);
}
attr = child->first_attribute("showrange");
if (attr)
mShowRange = atoi(attr->value());
attr = child->first_attribute("showcurr");
if (attr)
mShowCurr = atoi(attr->value());
attr = child->first_attribute("changeondrag");
if (attr)
mChangeOnDrag = atoi(attr->value());
}
child = node->first_node("dimensions");
if (child)
{
attr = child->first_attribute("lineh");
if (attr)
{
string parsevalue = gui_parse_text(attr->value());
mLineH = atoi(parsevalue.c_str());
}
attr = child->first_attribute("linepadding");
if (attr)
{
string parsevalue = gui_parse_text(attr->value());
mPadding = atoi(parsevalue.c_str());
}
attr = child->first_attribute("sliderw");
if (attr)
{
string parsevalue = gui_parse_text(attr->value());
mSliderW = atoi(parsevalue.c_str());
}
attr = child->first_attribute("sliderh");
if (attr)
{
string parsevalue = gui_parse_text(attr->value());
mSliderH = atoi(parsevalue.c_str());
}
}
gr_getFontDetails(mFont ? mFont->GetResource() : NULL, (unsigned*) &mFontHeight, NULL);
if(mShowCurr)
{
int maxLen = std::max(strlen(mMinStr.c_str()), strlen(mMaxStr.c_str()));
mValueStr = new char[maxLen+1];
}
loadValue(true);
mLinePadding = mPadding;
if (mShowRange)
{
int textW = std::max(measureText(mMaxStr), measureText(mMinStr));
mLinePadding += textW;
}
SetRenderPos(mRenderX, mRenderY, mRenderW);
}
GUIFileSelector::GUIFileSelector(xml_node<>* node)
{
xml_attribute<>* attr;
xml_node<>* child;
int header_separator_color_specified = 0, header_separator_height_specified = 0, header_text_color_specified = 0, header_background_color_specified = 0;
mStart = mLineSpacing = startY = mFontHeight = mSeparatorH = scrollingY = scrollingSpeed = 0;
mIconWidth = mIconHeight = mFolderIconHeight = mFileIconHeight = mFolderIconWidth = mFileIconWidth = mHeaderIconHeight = mHeaderIconWidth = 0;
mHeaderSeparatorH = mLineHeight = mHeaderIsStatic = mHeaderH = actualLineHeight = 0;
mFolderIcon = mFileIcon = mBackground = mFont = mHeaderIcon = NULL;
mBackgroundX = mBackgroundY = mBackgroundW = mBackgroundH = 0;
mShowFolders = mShowFiles = mShowNavFolders = 1;
mUpdate = 0;
touchDebounce = 6;
mPathVar = "cwd";
ConvertStrToColor("black", &mBackgroundColor);
ConvertStrToColor("black", &mHeaderBackgroundColor);
ConvertStrToColor("black", &mSeparatorColor);
ConvertStrToColor("black", &mHeaderSeparatorColor);
ConvertStrToColor("white", &mFontColor);
ConvertStrToColor("white", &mHeaderFontColor);
// Load header text
child = node->first_node("header");
if (child)
{
attr = child->first_attribute("icon");
if (attr)
mHeaderIcon = PageManager::FindResource(attr->value());
attr = child->first_attribute("background");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderBackgroundColor);
header_background_color_specified = -1;
}
attr = child->first_attribute("textcolor");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderFontColor);
header_text_color_specified = -1;
}
attr = child->first_attribute("separatorcolor");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderSeparatorColor);
header_separator_color_specified = -1;
}
attr = child->first_attribute("separatorheight");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mHeaderSeparatorH = atoi(parsevalue.c_str());
header_separator_height_specified = -1;
}
}
child = node->first_node("text");
if (child) mHeaderText = child->value();
// Simple way to check for static state
mLastValue = gui_parse_text(mHeaderText);
if (mLastValue != mHeaderText)
mHeaderIsStatic = 0;
else
mHeaderIsStatic = -1;
child = node->first_node("icon");
if (child)
{
attr = child->first_attribute("folder");
if (attr)
mFolderIcon = PageManager::FindResource(attr->value());
attr = child->first_attribute("file");
if (attr)
mFileIcon = PageManager::FindResource(attr->value());
}
child = node->first_node("background");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mBackground = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mBackgroundColor);
if (!header_background_color_specified)
ConvertStrToColor(color, &mHeaderBackgroundColor);
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
// Load the font, and possibly override the color
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mFont = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mFontColor);
if (!header_text_color_specified)
ConvertStrToColor(color, &mHeaderFontColor);
}
attr = child->first_attribute("spacing");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mLineSpacing = atoi(parsevalue.c_str());
}
}
// Load the separator if it exists
child = node->first_node("separator");
if (child)
{
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mSeparatorColor);
if (!header_separator_color_specified)
ConvertStrToColor(color, &mHeaderSeparatorColor);
}
attr = child->first_attribute("height");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mSeparatorH = atoi(parsevalue.c_str());
if (!header_separator_height_specified)
mHeaderSeparatorH = mSeparatorH;
}
}
child = node->first_node("filter");
if (child)
{
attr = child->first_attribute("extn");
if (attr)
mExtn = attr->value();
attr = child->first_attribute("folders");
if (attr)
mShowFolders = atoi(attr->value());
attr = child->first_attribute("files");
if (attr)
mShowFiles = atoi(attr->value());
attr = child->first_attribute("nav");
if (attr)
mShowNavFolders = atoi(attr->value());
}
// Handle the path variable
child = node->first_node("path");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mPathVar = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mPathVar, attr->value());
}
// Handle the result variable
child = node->first_node("data");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mVariable = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mVariable, attr->value());
}
// Handle the sort variable
child = node->first_node("sort");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mSortVariable = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mSortVariable, attr->value());
DataManager::GetValue(mSortVariable, mSortOrder);
}
// Handle the selection variable
child = node->first_node("selection");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mSelection = attr->value();
else
mSelection = "0";
} else
mSelection = "0";
// Retrieve the line height
gr_getFontDetails(mFont ? mFont->GetResource() : NULL, &mFontHeight, NULL);
mLineHeight = mFontHeight;
mHeaderH = mFontHeight;
if (mFolderIcon && mFolderIcon->GetResource())
{
mFolderIconWidth = gr_get_width(mFolderIcon->GetResource());
mFolderIconHeight = gr_get_height(mFolderIcon->GetResource());
if (mFolderIconHeight > (int)mLineHeight)
mLineHeight = mFolderIconHeight;
mIconWidth = mFolderIconWidth;
}
if (mFileIcon && mFileIcon->GetResource())
{
mFileIconWidth = gr_get_width(mFileIcon->GetResource());
mFileIconHeight = gr_get_height(mFileIcon->GetResource());
if (mFileIconHeight > (int)mLineHeight)
mLineHeight = mFileIconHeight;
if (mFileIconWidth > mIconWidth)
mIconWidth = mFileIconWidth;
}
if (mHeaderIcon && mHeaderIcon->GetResource())
{
mHeaderIconWidth = gr_get_width(mHeaderIcon->GetResource());
mHeaderIconHeight = gr_get_height(mHeaderIcon->GetResource());
if (mHeaderIconHeight > mHeaderH)
mHeaderH = mHeaderIconHeight;
if (mHeaderIconWidth > mIconWidth)
mIconWidth = mHeaderIconWidth;
}
mHeaderH += mLineSpacing + mHeaderSeparatorH;
actualLineHeight = mLineHeight + mLineSpacing + mSeparatorH;
if (mHeaderH < actualLineHeight)
mHeaderH = actualLineHeight;
if (actualLineHeight / 3 > 6)
touchDebounce = actualLineHeight / 3;
if (mBackground && mBackground->GetResource())
{
mBackgroundW = gr_get_width(mBackground->GetResource());
mBackgroundH = gr_get_height(mBackground->GetResource());
}
// Fetch the file/folder list
std::string value;
DataManager::GetValue(mPathVar, value);
if (GetFileList(value) != 0 && (mShowNavFolders != 0 || mShowFiles != 0)) {
GetFileList(DataManager::GetCurrentStoragePath());
DataManager::SetValue(mPathVar, DataManager::GetCurrentStoragePath());
}
}
GUIButton::GUIButton(xml_node<>* node)
: GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mButtonImg = NULL;
mButtonIcon = NULL;
mButtonLabel = NULL;
mAction = NULL;
mRendered = false;
hasHighlightColor = false;
renderHighlight = false;
hasFill = false;
if (!node) return;
// These can be loaded directly from the node
mButtonLabel = new GUIText(node);
mAction = new GUIAction(node);
mButtonImg = new GUIImage(node);
if (mButtonImg->Render() < 0)
{
delete mButtonImg;
mButtonImg = NULL;
}
if (mButtonLabel->Render() < 0)
{
delete mButtonLabel;
mButtonLabel = NULL;
}
// Load fill if it exists
mFillColor = LoadAttrColor(FindNode(node, "fill"), "color", &hasFill);
if (!hasFill && mButtonImg == NULL) {
LOGERR("No image resource or fill specified for button.\n");
}
// The icon is a special case
mButtonIcon = LoadAttrImage(FindNode(node, "icon"), "resource");
mHighlightColor = LoadAttrColor(FindNode(node, "highlight"), "color", &hasHighlightColor);
int x, y, w, h;
TextPlacement = TOP_LEFT;
if (mButtonImg) {
mButtonImg->GetRenderPos(x, y, w, h);
} else if (hasFill) {
LoadPlacement(FindNode(node, "placement"), &x, &y, &w, &h, &TextPlacement);
}
SetRenderPos(x, y, w, h);
if (mButtonLabel) {
TextPlacement = (Placement)LoadAttrInt(FindNode(node, "placement"), "textplacement", TOP_LEFT);
if (TextPlacement != TEXT_ONLY_RIGHT) {
mButtonLabel->scaleWidth = 1;
mButtonLabel->SetMaxWidth(w);
mButtonLabel->SetPlacement(CENTER);
mTextX = ((mRenderW / 2) + mRenderX);
mTextY = mRenderY + (mRenderH / 2);
mButtonLabel->SetRenderPos(mTextX, mTextY);
} else {
mTextX = mRenderW + mRenderX + 5;
mButtonLabel->GetCurrentBounds(mTextW, mTextH);
mRenderW += mTextW + 5;
mTextY = mRenderY + (mRenderH / 2) - (mTextH / 2);
mButtonLabel->SetRenderPos(mTextX, mTextY);
if (mAction)
mAction->SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
}
}
}
GUIKeyboard::GUIKeyboard(xml_node<>* node)
: GUIObject(node)
{
int layoutindex, rowindex, keyindex, Xindex, Yindex, keyHeight = 0, keyWidth = 0;
currentKey = NULL;
highlightRenderCount = 0;
hasHighlight = hasCapsHighlight = false;
char resource[10], layout[8], row[5], key[6], longpress[7];
xml_attribute<>* attr;
xml_node<>* child;
xml_node<>* keylayout;
xml_node<>* keyrow;
for (layoutindex=0; layoutindex<MAX_KEYBOARD_LAYOUTS; layoutindex++) {
layouts[layoutindex].keyboardImg = NULL;
memset(layouts[layoutindex].keys, 0, sizeof(Layout::keys));
memset(layouts[layoutindex].row_end_y, 0, sizeof(Layout::row_end_y));
}
mRendered = false;
currentLayout = 1;
CapsLockOn = false;
if (!node) return;
mHighlightColor = LoadAttrColor(FindNode(node, "highlight"), "color", &hasHighlight);
mCapsHighlightColor = LoadAttrColor(FindNode(node, "capshighlight"), "color", &hasCapsHighlight);
child = FindNode(node, "keymargin");
mKeyMarginX = LoadAttrIntScaleX(child, "x", 0);
mKeyMarginY = LoadAttrIntScaleY(child, "y", 0);
child = FindNode(node, "background");
mBackgroundColor = LoadAttrColor(child, "color", COLOR(32,32,32,255));
child = FindNode(node, "key-alphanumeric");
mFont = PageManager::GetResources()->FindFont(LoadAttrString(child, "font", "keylabel"));
mFontColor = LoadAttrColor(child, "textcolor", COLOR(255,255,255,255));
mKeyColorAlphanumeric = LoadAttrColor(child, "color", COLOR(0,0,0,0));
child = FindNode(node, "key-other");
mSmallFont = PageManager::GetResources()->FindFont(LoadAttrString(child, "font", "keylabel-small"));
mFontColorSmall = LoadAttrColor(child, "textcolor", COLOR(192,192,192,255));
mKeyColorOther = LoadAttrColor(child, "color", COLOR(0,0,0,0));
child = FindNode(node, "longpress");
mLongpressFont = PageManager::GetResources()->FindFont(LoadAttrString(child, "font", "keylabel-longpress"));
mLongpressFontColor = LoadAttrColor(child, "textcolor", COLOR(128,128,128,255));
LoadPlacement(child, &longpressOffsetX, &longpressOffsetY);
LoadKeyLabels(node, 0); // load global key labels
// compatibility ugliness: resources should be specified in the layouts themselves instead
// Load the images for the different layouts
child = FindNode(node, "layout");
if (child)
{
layoutindex = 1;
strcpy(resource, "resource1");
attr = child->first_attribute(resource);
while (attr && layoutindex < (MAX_KEYBOARD_LAYOUTS + 1)) {
layouts[layoutindex - 1].keyboardImg = LoadAttrImage(child, resource);
layoutindex++;
resource[8] = (char)(layoutindex + 48);
attr = child->first_attribute(resource);
}
}
// Check the first image to get height and width
if (layouts[0].keyboardImg && layouts[0].keyboardImg->GetResource())
{
mRenderW = layouts[0].keyboardImg->GetWidth();
mRenderH = layouts[0].keyboardImg->GetHeight();
}
// Load all of the layout maps
layoutindex = 1;
strcpy(layout, "layout1");
keylayout = FindNode(node, layout);
while (keylayout)
{
if (layoutindex > MAX_KEYBOARD_LAYOUTS) {
LOGERR("Too many layouts defined in keyboard.\n");
return;
}
LoadKeyLabels(keylayout, layoutindex); // load per-layout key labels
Layout& lay = layouts[layoutindex - 1];
child = keylayout->first_node("keysize");
keyHeight = LoadAttrIntScaleY(child, "height", 0);
keyWidth = LoadAttrIntScaleX(child, "width", 0);
// compatibility ugliness: capslock="0" means that this is the caps layout. Also it has nothing to do with keysize.
lay.is_caps = (LoadAttrInt(child, "capslock", 1) == 0);
// compatibility ugliness: revert_layout has nothing to do with keysize.
lay.revert_layout = LoadAttrInt(child, "revert_layout", -1);
rowindex = 1;
Yindex = 0;
strcpy(row, "row1");
keyrow = keylayout->first_node(row);
while (keyrow)
{
if (rowindex > MAX_KEYBOARD_ROWS) {
LOGERR("Too many rows defined in keyboard.\n");
return;
}
Yindex += keyHeight;
lay.row_end_y[rowindex - 1] = Yindex;
keyindex = 1;
Xindex = 0;
strcpy(key, "key01");
attr = keyrow->first_attribute(key);
while (attr) {
if (keyindex > MAX_KEYBOARD_KEYS) {
LOGERR("Too many keys defined in a keyboard row.\n");
return;
}
const char* keyinfo = attr->value();
if (strlen(keyinfo) == 0) {
LOGERR("No key info on layout%i, row%i, key%dd.\n", layoutindex, rowindex, keyindex);
return;
}
if (ParseKey(keyinfo, lay.keys[rowindex - 1][keyindex - 1], Xindex, keyWidth, false))
LOGERR("Invalid key info on layout%i, row%i, key%02i.\n", layoutindex, rowindex, keyindex);
// PROCESS LONG PRESS INFO IF EXISTS
sprintf(longpress, "long%02i", keyindex);
attr = keyrow->first_attribute(longpress);
if (attr) {
const char* keyinfo = attr->value();
if (strlen(keyinfo) == 0) {
LOGERR("No long press info on layout%i, row%i, long%dd.\n", layoutindex, rowindex, keyindex);
return;
}
if (ParseKey(keyinfo, lay.keys[rowindex - 1][keyindex - 1], Xindex, keyWidth, true))
LOGERR("Invalid long press key info on layout%i, row%i, long%02i.\n", layoutindex, rowindex, keyindex);
}
keyindex++;
sprintf(key, "key%02i", keyindex);
attr = keyrow->first_attribute(key);
}
rowindex++;
row[3] = (char)(rowindex + 48);
keyrow = keylayout->first_node(row);
}
layoutindex++;
layout[6] = (char)(layoutindex + 48);
keylayout = FindNode(node, layout);
}
int x, y;
// Load the placement
LoadPlacement(FindNode(node, "placement"), &x, &y, &mRenderW, &mRenderH);
SetRenderPos(x, y, mRenderW, mRenderH);
return;
}
GUISlider::GUISlider(xml_node<>* node) : GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
sAction = NULL;
sSliderLabel = NULL;
sSlider = NULL;
sSliderUsed = NULL;
sTouch = NULL;
sTouchW = 20;
if (!node)
{
LOGERR("GUISlider created without XML node\n");
return;
}
// Load the resources
child = FindNode(node, "resource");
if (child)
{
sSlider = LoadAttrImage(child, "base");
sSliderUsed = LoadAttrImage(child, "used");
sTouch = LoadAttrImage(child, "touch");
}
// Load the text label
sSliderLabel = new GUIText(node);
if (sSliderLabel->Render() < 0)
{
delete sSliderLabel;
sSliderLabel = NULL;
}
// Load the placement
Placement TextPlacement = CENTER;
LoadPlacement(FindNode(node, "placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH, &TextPlacement);
mRenderW = sSlider->GetWidth();
mRenderH = sSlider->GetHeight();
if (TextPlacement == CENTER || TextPlacement == CENTER_X_ONLY) {
mRenderX = mRenderX - (mRenderW / 2);
if (TextPlacement == CENTER) {
mRenderY = mRenderY - (mRenderH / 2);
}
}
if (sSliderLabel) {
int sTextX = mRenderX + (mRenderW / 2);
int w, h;
sSliderLabel->GetCurrentBounds(w, h);
int sTextY = mRenderY + ((mRenderH - h) / 2);
sSliderLabel->SetRenderPos(sTextX, sTextY);
sSliderLabel->SetMaxWidth(mRenderW);
}
if (sTouch && sTouch->GetResource())
{
sTouchW = sTouch->GetWidth(); // Width of the "touch image" that follows the touch (arrow)
sTouchH = sTouch->GetHeight(); // Height of the "touch image" that follows the touch (arrow)
}
//LOGINFO("mRenderW: %i mTouchW: %i\n", mRenderW, mTouchW);
mActionX = mRenderX;
mActionY = mRenderY;
mActionW = mRenderW;
mActionH = mRenderH;
sAction = new GUIAction(node);
sCurTouchX = mRenderX;
sUpdate = 1;
}
GUIListBox::GUIListBox(xml_node<>* node) : Conditional(node)
{
xml_attribute<>* attr;
xml_node<>* child;
int header_separator_color_specified = 0, header_separator_height_specified = 0, header_text_color_specified = 0, header_background_color_specified = 0;
mStart = mLineSpacing = startY = mFontHeight = mSeparatorH = scrollingY = scrollingSpeed = 0;
mIconWidth = mIconHeight = mSelectedIconHeight = mSelectedIconWidth = mUnselectedIconHeight = mUnselectedIconWidth = mHeaderIconHeight = mHeaderIconWidth = 0;
mHeaderSeparatorH = mLineHeight = mHeaderIsStatic = mHeaderH = actualLineHeight = 0;
mIconSelected = mIconUnselected = mBackground = mFont = mHeaderIcon = NULL;
mBackgroundX = mBackgroundY = mBackgroundW = mBackgroundH = 0;
mFastScrollW = mFastScrollLineW = mFastScrollRectW = mFastScrollRectH = 0;
mFastScrollRectX = mFastScrollRectY = -1;
mUpdate = 0;
touchDebounce = 6;
ConvertStrToColor("black", &mBackgroundColor);
ConvertStrToColor("black", &mHeaderBackgroundColor);
ConvertStrToColor("black", &mSeparatorColor);
ConvertStrToColor("black", &mHeaderSeparatorColor);
ConvertStrToColor("white", &mFontColor);
ConvertStrToColor("white", &mHeaderFontColor);
ConvertStrToColor("white", &mFastScrollLineColor);
ConvertStrToColor("white", &mFastScrollRectColor);
hasHighlightColor = false;
hasFontHighlightColor = false;
isHighlighted = false;
startSelection = -1;
// Load header text
child = node->first_node("header");
if (child)
{
attr = child->first_attribute("icon");
if (attr)
mHeaderIcon = PageManager::FindResource(attr->value());
attr = child->first_attribute("background");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderBackgroundColor);
header_background_color_specified = -1;
}
attr = child->first_attribute("textcolor");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderFontColor);
header_text_color_specified = -1;
}
attr = child->first_attribute("separatorcolor");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mHeaderSeparatorColor);
header_separator_color_specified = -1;
}
attr = child->first_attribute("separatorheight");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mHeaderSeparatorH = atoi(parsevalue.c_str());
header_separator_height_specified = -1;
}
}
child = node->first_node("text");
if (child) mHeaderText = child->value();
memset(&mHighlightColor, 0, sizeof(COLOR));
child = node->first_node("highlight");
if (child) {
attr = child->first_attribute("color");
if (attr) {
hasHighlightColor = true;
std::string color = attr->value();
ConvertStrToColor(color, &mHighlightColor);
}
}
// Simple way to check for static state
mLastValue = gui_parse_text(mHeaderText);
if (mLastValue != mHeaderText)
mHeaderIsStatic = 0;
else
mHeaderIsStatic = -1;
child = node->first_node("icon");
if (child)
{
attr = child->first_attribute("selected");
if (attr)
mIconSelected = PageManager::FindResource(attr->value());
attr = child->first_attribute("unselected");
if (attr)
mIconUnselected = PageManager::FindResource(attr->value());
}
child = node->first_node("background");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mBackground = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mBackgroundColor);
if (!header_background_color_specified)
ConvertStrToColor(color, &mHeaderBackgroundColor);
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
// Load the font, and possibly override the color
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mFont = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mFontColor);
if (!header_text_color_specified)
ConvertStrToColor(color, &mHeaderFontColor);
}
attr = child->first_attribute("spacing");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mLineSpacing = atoi(parsevalue.c_str());
}
attr = child->first_attribute("highlightcolor");
memset(&mFontHighlightColor, 0, sizeof(COLOR));
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mFontHighlightColor);
hasFontHighlightColor = true;
}
}
// Load the separator if it exists
child = node->first_node("separator");
if (child)
{
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mSeparatorColor);
if (!header_separator_color_specified)
ConvertStrToColor(color, &mHeaderSeparatorColor);
}
attr = child->first_attribute("height");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mSeparatorH = atoi(parsevalue.c_str());
if (!header_separator_height_specified)
mHeaderSeparatorH = mSeparatorH;
}
}
// Handle the result variable
child = node->first_node("data");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mVariable = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mVariable, attr->value());
}
// Fast scroll colors
child = node->first_node("fastscroll");
if (child)
{
attr = child->first_attribute("linecolor");
if(attr)
ConvertStrToColor(attr->value(), &mFastScrollLineColor);
attr = child->first_attribute("rectcolor");
if(attr)
ConvertStrToColor(attr->value(), &mFastScrollRectColor);
attr = child->first_attribute("w");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollW = atoi(parsevalue.c_str());
}
attr = child->first_attribute("linew");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollLineW = atoi(parsevalue.c_str());
}
attr = child->first_attribute("rectw");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollRectW = atoi(parsevalue.c_str());
}
attr = child->first_attribute("recth");
if (attr) {
string parsevalue = gui_parse_text(attr->value());
mFastScrollRectH = atoi(parsevalue.c_str());
}
}
// Retrieve the line height
gr_getFontDetails(mFont ? mFont->GetResource() : NULL, &mFontHeight, NULL);
mLineHeight = mFontHeight;
mHeaderH = mFontHeight;
if (mIconSelected && mIconSelected->GetResource())
{
mSelectedIconWidth = gr_get_width(mIconSelected->GetResource());
mSelectedIconHeight = gr_get_height(mIconSelected->GetResource());
if (mSelectedIconHeight > (int)mLineHeight)
mLineHeight = mSelectedIconHeight;
mIconWidth = mSelectedIconWidth;
}
if (mIconUnselected && mIconUnselected->GetResource())
{
mUnselectedIconWidth = gr_get_width(mIconUnselected->GetResource());
mUnselectedIconHeight = gr_get_height(mIconUnselected->GetResource());
if (mUnselectedIconHeight > (int)mLineHeight)
mLineHeight = mUnselectedIconHeight;
if (mUnselectedIconWidth > mIconWidth)
mIconWidth = mUnselectedIconWidth;
}
if (mHeaderIcon && mHeaderIcon->GetResource())
{
mHeaderIconWidth = gr_get_width(mHeaderIcon->GetResource());
mHeaderIconHeight = gr_get_height(mHeaderIcon->GetResource());
if (mHeaderIconHeight > mHeaderH)
mHeaderH = mHeaderIconHeight;
if (mHeaderIconWidth > mIconWidth)
mIconWidth = mHeaderIconWidth;
}
mHeaderH += mLineSpacing + mHeaderSeparatorH;
actualLineHeight = mLineHeight + mLineSpacing + mSeparatorH;
if (mHeaderH < actualLineHeight)
mHeaderH = actualLineHeight;
if (actualLineHeight / 3 > 6)
touchDebounce = actualLineHeight / 3;
if (mBackground && mBackground->GetResource())
{
mBackgroundW = gr_get_width(mBackground->GetResource());
mBackgroundH = gr_get_height(mBackground->GetResource());
}
// Get the currently selected value for the list
DataManager::GetValue(mVariable, currentValue);
// Get the data for the list
child = node->first_node("listitem");
while (child)
{
ListData data;
attr = child->first_attribute("name");
if (!attr) return;
data.displayName = attr->value();
data.variableValue = child->value();
if (child->value() == currentValue) {
data.selected = 1;
} else {
data.selected = 0;
}
mList.push_back(data);
child = child->next_sibling("listitem");
}
// Load dynamic data
child = node->first_node("items");
if (child)
mItemsVar = child->value();
// Call this to get the selected item to be shown in the list on first render
NotifyVarChange(mVariable, currentValue);
if(!mItemsVar.empty())
NotifyVarChange(mItemsVar, DataManager::GetStrValue(mItemsVar));
}
GUIKeyboard::GUIKeyboard(xml_node<>* node)
: GUIObject(node)
{
int layoutindex, rowindex, keyindex, Xindex, Yindex, keyHeight = 0, keyWidth = 0;
rowY = colX = -1;
highlightRenderCount = 0;
hasHighlight = hasCapsHighlight = false;
char resource[10], layout[8], row[5], key[6], longpress[7];
xml_attribute<>* attr;
xml_node<>* child;
xml_node<>* keylayout;
xml_node<>* keyrow;
for (layoutindex=0; layoutindex<MAX_KEYBOARD_LAYOUTS; layoutindex++) {
layouts[layoutindex].keyboardImg = NULL;
memset(layouts[layoutindex].keys, 0, sizeof(Layout::keys));
memset(layouts[layoutindex].row_end_y, 0, sizeof(Layout::row_end_y));
}
mRendered = false;
currentLayout = 1;
CapsLockOn = false;
KeyboardHeight = KeyboardWidth = 0;
if (!node) return;
mHighlightColor = LoadAttrColor(FindNode(node, "highlight"), "color", &hasHighlight);
mCapsHighlightColor = LoadAttrColor(FindNode(node, "capshighlight"), "color", &hasCapsHighlight);
// compatibility ugliness: resources should be specified in the layouts themselves instead
// Load the images for the different layouts
child = FindNode(node, "layout");
if (child)
{
layoutindex = 1;
strcpy(resource, "resource1");
attr = child->first_attribute(resource);
while (attr && layoutindex < (MAX_KEYBOARD_LAYOUTS + 1)) {
layouts[layoutindex - 1].keyboardImg = LoadAttrImage(child, resource);
layoutindex++;
resource[8] = (char)(layoutindex + 48);
attr = child->first_attribute(resource);
}
}
// Check the first image to get height and width
if (layouts[0].keyboardImg && layouts[0].keyboardImg->GetResource())
{
KeyboardWidth = layouts[0].keyboardImg->GetWidth();
KeyboardHeight = layouts[0].keyboardImg->GetHeight();
}
// Load all of the layout maps
layoutindex = 1;
strcpy(layout, "layout1");
keylayout = FindNode(node, layout);
while (keylayout)
{
if (layoutindex > MAX_KEYBOARD_LAYOUTS) {
LOGERR("Too many layouts defined in keyboard.\n");
return;
}
Layout& lay = layouts[layoutindex - 1];
child = keylayout->first_node("keysize");
keyHeight = LoadAttrIntScaleY(child, "height", 0);
keyWidth = LoadAttrIntScaleX(child, "width", 0);
// compatibility ugliness: capslock="0" means that this is the caps layout. Also it has nothing to do with keysize.
lay.is_caps = (LoadAttrInt(child, "capslock", 1) == 0);
// compatibility ugliness: revert_layout has nothing to do with keysize.
lay.revert_layout = LoadAttrInt(child, "revert_layout", -1);
rowindex = 1;
Yindex = 0;
strcpy(row, "row1");
keyrow = keylayout->first_node(row);
while (keyrow)
{
if (rowindex > MAX_KEYBOARD_ROWS) {
LOGERR("Too many rows defined in keyboard.\n");
return;
}
Yindex += keyHeight;
lay.row_end_y[rowindex - 1] = Yindex;
keyindex = 1;
Xindex = 0;
strcpy(key, "key01");
attr = keyrow->first_attribute(key);
while (attr) {
if (keyindex > MAX_KEYBOARD_KEYS) {
LOGERR("Too many keys defined in a keyboard row.\n");
return;
}
const char* keyinfo = attr->value();
if (strlen(keyinfo) == 0) {
LOGERR("No key info on layout%i, row%i, key%dd.\n", layoutindex, rowindex, keyindex);
return;
}
if (ParseKey(keyinfo, lay.keys[rowindex - 1][keyindex - 1], Xindex, keyWidth, false))
LOGERR("Invalid key info on layout%i, row%i, key%02i.\n", layoutindex, rowindex, keyindex);
// PROCESS LONG PRESS INFO IF EXISTS
sprintf(longpress, "long%02i", keyindex);
attr = keyrow->first_attribute(longpress);
if (attr) {
const char* keyinfo = attr->value();
if (strlen(keyinfo) == 0) {
LOGERR("No long press info on layout%i, row%i, long%dd.\n", layoutindex, rowindex, keyindex);
return;
}
if (ParseKey(keyinfo, lay.keys[rowindex - 1][keyindex - 1], Xindex, keyWidth, true))
LOGERR("Invalid long press key info on layout%i, row%i, long%02i.\n", layoutindex, rowindex, keyindex);
}
keyindex++;
sprintf(key, "key%02i", keyindex);
attr = keyrow->first_attribute(key);
}
rowindex++;
row[3] = (char)(rowindex + 48);
keyrow = keylayout->first_node(row);
}
layoutindex++;
layout[6] = (char)(layoutindex + 48);
keylayout = FindNode(node, layout);
}
int x, y;
// Load the placement
LoadPlacement(FindNode(node, "placement"), &x, &y);
SetRenderPos(x, y, KeyboardWidth, KeyboardHeight);
return;
}
GUIButton::GUIButton(xml_node<>* node)
: Conditional(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mButtonImg = NULL;
mButtonIcon = NULL;
mButtonLabel = NULL;
mAction = NULL;
mRendered = false;
hasHighlightColor = false;
renderHighlight = false;
hasFill = false;
if (!node) return;
// Three of the four can be loaded directly from the node
mButtonImg = new GUIImage(node);
mButtonLabel = new GUIText(node);
mAction = new GUIAction(node);
if (mButtonImg->Render() < 0)
{
delete mButtonImg;
mButtonImg = NULL;
}
if (mButtonLabel->Render() < 0)
{
delete mButtonLabel;
mButtonLabel = NULL;
}
// Load fill if it exists
memset(&mFillColor, 0, sizeof(COLOR));
child = node->first_node("fill");
if (child)
{
attr = child->first_attribute("color");
if (attr) {
hasFill = true;
std::string color = attr->value();
ConvertStrToColor(color, &mFillColor);
}
}
if (!hasFill && mButtonImg == NULL) {
LOGERR("No image resource or fill specified for button.\n");
}
// The icon is a special case
child = node->first_node("icon");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mButtonIcon = PageManager::FindResource(attr->value());
}
memset(&mHighlightColor, 0, sizeof(COLOR));
child = node->first_node("highlight");
if (child) {
attr = child->first_attribute("color");
if (attr) {
hasHighlightColor = true;
std::string color = attr->value();
ConvertStrToColor(color, &mHighlightColor);
}
}
int x, y, w, h;
TextPlacement = TOP_LEFT;
if (mButtonImg) {
mButtonImg->GetRenderPos(x, y, w, h);
} else if (hasFill) {
LoadPlacement(node->first_node("placement"), &x, &y, &w, &h, &TextPlacement);
}
SetRenderPos(x, y, w, h);
return;
}
GUIInput::GUIInput(xml_node<>* node)
: GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mInputText = NULL;
mAction = NULL;
mBackground = NULL;
mCursor = NULL;
mFont = NULL;
mRendered = false;
HasMask = false;
DrawCursor = false;
isLocalChange = true;
HasAllowed = false;
HasDisabled = false;
skipChars = scrollingX = mFontHeight = mFontY = lastX = 0;
mBackgroundX = mBackgroundY = mBackgroundW = mBackgroundH = MinLen = MaxLen = 0;
mCursorLocation = -1; // -1 is always the end of the string
CursorWidth = 3;
ConvertStrToColor("black", &mBackgroundColor);
ConvertStrToColor("white", &mCursorColor);
if (!node)
return;
// Load text directly from the node
mInputText = new GUIText(node);
// Load action directly from the node
mAction = new GUIAction(node);
if (mInputText->Render() < 0)
{
delete mInputText;
mInputText = NULL;
}
// Load the background
child = node->first_node("background");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mBackground = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mBackgroundColor);
}
}
if (mBackground && mBackground->GetResource())
{
mBackgroundW = gr_get_width(mBackground->GetResource());
mBackgroundH = gr_get_height(mBackground->GetResource());
}
// Load the cursor color
child = node->first_node("cursor");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mCursor = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mCursorColor);
}
attr = child->first_attribute("hasfocus");
if (attr)
{
std::string color = attr->value();
SetInputFocus(atoi(color.c_str()));
}
attr = child->first_attribute("width");
if (attr)
{
std::string cwidth = gui_parse_text(attr->value());
CursorWidth = atoi(cwidth.c_str());
}
}
DrawCursor = HasInputFocus;
// Load the font, and possibly override the color
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr) {
mFont = PageManager::FindResource(attr->value());
mFontHeight = gr_getMaxFontHeight(mFont ? mFont->GetResource() : NULL);
}
}
child = node->first_node("text");
if (child) mText = child->value();
mLastValue = gui_parse_text(mText);
child = node->first_node("data");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mVariable = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mVariable, attr->value());
attr = child->first_attribute("mask");
if (attr) {
mMask = attr->value();
HasMask = true;
}
attr = child->first_attribute("maskvariable");
if (attr)
mMaskVariable = attr->value();
else
mMaskVariable = mVariable;
}
// Load input restrictions
child = node->first_node("restrict");
if (child)
{
attr = child->first_attribute("minlen");
if (attr) {
std::string attrib = attr->value();
MinLen = atoi(attrib.c_str());
}
attr = child->first_attribute("maxlen");
if (attr) {
std::string attrib = attr->value();
MaxLen = atoi(attrib.c_str());
}
attr = child->first_attribute("allow");
if (attr) {
HasAllowed = true;
AllowedList = attr->value();
}
attr = child->first_attribute("disable");
if (attr) {
HasDisabled = true;
DisabledList = attr->value();
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
if (mInputText && mFontHeight && mFontHeight < (unsigned)mRenderH) {
mFontY = ((mRenderH - mFontHeight) / 2) + mRenderY;
mInputText->SetRenderPos(mRenderX, mFontY);
} else
mFontY = mRenderY;
if (mInputText)
mInputText->SetMaxWidth(mRenderW);
isLocalChange = false;
HandleTextLocation(-3);
}
GUIKeyboard::GUIKeyboard(xml_node<>* node)
: Conditional(node)
{
int layoutindex, rowindex, keyindex, Xindex, Yindex, keyHeight = 0, keyWidth = 0;
rowY = colX = -1;
highlightRenderCount = hasHighlight = 0;
char resource[10], layout[8], row[5], key[6], longpress[7];
xml_attribute<>* attr;
xml_node<>* child;
xml_node<>* keylayout;
xml_node<>* keyrow;
for (layoutindex=0; layoutindex<MAX_KEYBOARD_LAYOUTS; layoutindex++)
keyboardImg[layoutindex] = NULL;
mRendered = false;
currentLayout = 1;
mAction = NULL;
KeyboardHeight = KeyboardWidth = cursorLocation = 0;
if (!node) return;
// Load the action
child = node->first_node("action");
if (child)
{
mAction = new GUIAction(node);
}
memset(&mHighlightColor, 0, sizeof(COLOR));
child = node->first_node("highlight");
if (child) {
attr = child->first_attribute("color");
if (attr) {
hasHighlight = 1;
std::string color = attr->value();
ConvertStrToColor(color, &mHighlightColor);
}
}
// Load the images for the different layouts
child = node->first_node("layout");
if (child)
{
layoutindex = 1;
strcpy(resource, "resource1");
attr = child->first_attribute(resource);
while (attr && layoutindex < (MAX_KEYBOARD_LAYOUTS + 1)) {
keyboardImg[layoutindex - 1] = PageManager::FindResource(attr->value());
layoutindex++;
resource[8] = (char)(layoutindex + 48);
attr = child->first_attribute(resource);
}
}
// Check the first image to get height and width
if (keyboardImg[0] && keyboardImg[0]->GetResource())
{
KeyboardWidth = gr_get_width(keyboardImg[0]->GetResource());
KeyboardHeight = gr_get_height(keyboardImg[0]->GetResource());
}
// Load all of the layout maps
layoutindex = 1;
strcpy(layout, "layout1");
keylayout = node->first_node(layout);
while (keylayout)
{
if (layoutindex > MAX_KEYBOARD_LAYOUTS) {
LOGERR("Too many layouts defined in keyboard.\n");
return;
}
child = keylayout->first_node("keysize");
if (child) {
attr = child->first_attribute("height");
if (attr)
keyHeight = atoi(attr->value());
else
keyHeight = 0;
attr = child->first_attribute("width");
if (attr)
keyWidth = atoi(attr->value());
else
keyWidth = 0;
}
rowindex = 1;
Yindex = 0;
strcpy(row, "row1");
keyrow = keylayout->first_node(row);
while (keyrow)
{
if (rowindex > MAX_KEYBOARD_ROWS) {
LOGERR("Too many rows defined in keyboard.\n");
return;
}
Yindex += keyHeight;
row_heights[layoutindex - 1][rowindex - 1] = Yindex;
keyindex = 1;
Xindex = 0;
strcpy(key, "key01");
attr = keyrow->first_attribute(key);
while (attr) {
string stratt;
char keyinfo[255];
if (keyindex > MAX_KEYBOARD_KEYS) {
LOGERR("Too many keys defined in a keyboard row.\n");
return;
}
stratt = attr->value();
if (strlen(stratt.c_str()) >= 255) {
LOGERR("Key info on layout%i, row%i, key%dd is too long.\n", layoutindex, rowindex, keyindex);
return;
}
strcpy(keyinfo, stratt.c_str());
if (strlen(keyinfo) == 0) {
LOGERR("No key info on layout%i, row%i, key%dd.\n", layoutindex, rowindex, keyindex);
return;
}
if (strlen(keyinfo) == 1) {
// This is a single key, simple definition
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].key = keyinfo[0];
Xindex += keyWidth;
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].end_x = Xindex - 1;
} else {
// This key has extra data
char* ptr;
char* offset;
char* keyitem;
char foratoi[10];
ptr = keyinfo;
offset = keyinfo;
while (*ptr > 32 && *ptr != ':')
ptr++;
if (*ptr != 0)
*ptr = 0;
strcpy(foratoi, offset);
Xindex += atoi(foratoi);
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].end_x = Xindex - 1;
ptr++;
if (*ptr == 0) {
// This is an empty area
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].key = 0;
} else if (strlen(ptr) == 1) {
// This is the character that this key uses
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].key = *ptr;
} else if (*ptr == 'c') {
// This is an ASCII character code
keyitem = ptr + 2;
strcpy(foratoi, keyitem);
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].key = atoi(foratoi);
} else if (*ptr == 'l') {
// This is a different layout
keyitem = ptr + 6;
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].key = KEYBOARD_LAYOUT;
strcpy(foratoi, keyitem);
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].layout = atoi(foratoi);
} else if (*ptr == 'a') {
// This is an action
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].key = KEYBOARD_ACTION;
} else
LOGERR("Invalid key info on layout%i, row%i, key%02i.\n", layoutindex, rowindex, keyindex);
}
// PROCESS LONG PRESS INFO IF EXISTS
sprintf(longpress, "long%02i", keyindex);
attr = keyrow->first_attribute(longpress);
if (attr) {
stratt = attr->value();
if (strlen(stratt.c_str()) >= 255) {
LOGERR("Key info on layout%i, row%i, key%dd is too long.\n", layoutindex, rowindex, keyindex);
return;
}
strcpy(keyinfo, stratt.c_str());
if (strlen(keyinfo) == 0) {
LOGERR("No long press info on layout%i, row%i, long%dd.\n", layoutindex, rowindex, keyindex);
return;
}
if (strlen(keyinfo) == 1) {
// This is a single key, simple definition
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].longpresskey = keyinfo[0];
} else {
// This key has extra data
char* ptr;
char* offset;
char* keyitem;
char foratoi[10];
ptr = keyinfo;
offset = keyinfo;
while (*ptr > 32 && *ptr != ':')
ptr++;
if (*ptr != 0)
*ptr = 0;
strcpy(foratoi, offset);
Xindex += atoi(foratoi);
ptr++;
if (*ptr == 0) {
// This is an empty area
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].longpresskey = 0;
} else if (strlen(ptr) == 1) {
// This is the character that this key uses
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].longpresskey = *ptr;
} else if (*ptr == 'c') {
// This is an ASCII character code
keyitem = ptr + 2;
strcpy(foratoi, keyitem);
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].longpresskey = atoi(foratoi);
} else if (*ptr == 'l') {
// This is a different layout
keyitem = ptr + 6;
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].longpresskey = KEYBOARD_LAYOUT;
strcpy(foratoi, keyitem);
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].layout = atoi(foratoi);
} else if (*ptr == 'a') {
// This is an action
keyboard_keys[layoutindex - 1][rowindex - 1][keyindex - 1].longpresskey = KEYBOARD_ACTION;
} else
LOGERR("Invalid long press key info on layout%i, row%i, long%02i.\n", layoutindex, rowindex, keyindex);
}
}
keyindex++;
sprintf(key, "key%02i", keyindex);
attr = keyrow->first_attribute(key);
}
rowindex++;
row[3] = (char)(rowindex + 48);
keyrow = keylayout->first_node(row);
}
layoutindex++;
layout[6] = (char)(layoutindex + 48);
keylayout = node->first_node(layout);
}
int x, y, w, h;
// Load the placement
LoadPlacement(node->first_node("placement"), &x, &y, &w, &h);
SetActionPos(x, y, KeyboardWidth, KeyboardHeight);
SetRenderPos(x, y, w, h);
return;
}
GUIConsole::GUIConsole(xml_node<>* node)
{
xml_attribute<>* attr;
xml_node<>* child;
mFont = NULL;
mCurrentLine = -1;
memset(&mForegroundColor, 255, sizeof(COLOR));
memset(&mBackgroundColor, 0, sizeof(COLOR));
mBackgroundColor.alpha = 255;
memset(&mScrollColor, 0x08, sizeof(COLOR));
mScrollColor.alpha = 255;
mLastCount = 0;
mSlideout = 0;
mSlideoutState = hidden;
mRenderX = 0; mRenderY = 0; mRenderW = gr_fb_width(); mRenderH = gr_fb_height();
if (!node)
{
mSlideoutX = 0; mSlideoutY = 0; mSlideoutW = 0; mSlideoutH = 0;
mConsoleX = 0; mConsoleY = 0; mConsoleW = gr_fb_width(); mConsoleH = gr_fb_height();
}
else
{
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mFont = PageManager::FindResource(attr->value());
}
child = node->first_node("color");
if (child)
{
attr = child->first_attribute("foreground");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mForegroundColor);
}
attr = child->first_attribute("background");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mBackgroundColor);
}
attr = child->first_attribute("scroll");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mScrollColor);
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mConsoleX, &mConsoleY, &mConsoleW, &mConsoleH);
child = node->first_node("slideout");
if (child)
{
mSlideout = 1;
LoadPlacement(child, &mSlideoutX, &mSlideoutY);
attr = child->first_attribute("resource");
if (attr) mSlideoutImage = PageManager::FindResource(attr->value());
if (mSlideoutImage && mSlideoutImage->GetResource())
{
mSlideoutW = gr_get_width(mSlideoutImage->GetResource());
mSlideoutH = gr_get_height(mSlideoutImage->GetResource());
}
}
}
gr_getFontDetails(mFont ? mFont->GetResource() : NULL, &mFontHeight, NULL);
//gr_getFontDetails(mFont, &mFontHeight, NULL);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
SetRenderPos(mConsoleX, mConsoleY);
return;
}
GUIFileSelector::GUIFileSelector(xml_node<>* node)
{
xml_attribute<>* attr;
xml_node<>* child;
mStart = mLineSpacing = mIconWidth = mIconHeight = 0;
mFolderIcon = mFileIcon = mBackground = mFont = NULL;
mBackgroundX = mBackgroundY = mBackgroundW = mBackgroundH = 0;
mShowFolders = mShowFiles = mShowNavFolders = 1;
mUpdate = 0;
mPathVar = "cwd";
ConvertStrToColor("black", &mBackgroundColor);
ConvertStrToColor("white", &mFontColor);
child = node->first_node("icon");
if (child)
{
attr = child->first_attribute("folder");
if (attr)
mFolderIcon = PageManager::FindResource(attr->value());
attr = child->first_attribute("file");
if (attr)
mFileIcon = PageManager::FindResource(attr->value());
}
child = node->first_node("background");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mBackground = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mBackgroundColor);
}
}
// Load the placement
LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW, &mRenderH);
SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
// Load the font, and possibly override the color
child = node->first_node("font");
if (child)
{
attr = child->first_attribute("resource");
if (attr)
mFont = PageManager::FindResource(attr->value());
attr = child->first_attribute("color");
if (attr)
{
std::string color = attr->value();
ConvertStrToColor(color, &mFontColor);
}
attr = child->first_attribute("spacing");
if (attr)
mLineSpacing = atoi(attr->value());
}
child = node->first_node("filter");
if (child)
{
attr = child->first_attribute("extn");
if (attr)
mExtn = attr->value();
attr = child->first_attribute("folders");
if (attr)
mShowFolders = atoi(attr->value());
attr = child->first_attribute("files");
if (attr)
mShowFiles = atoi(attr->value());
attr = child->first_attribute("nav");
if (attr)
mShowNavFolders = atoi(attr->value());
}
// Handle the path variable
child = node->first_node("path");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mPathVar = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mPathVar, attr->value());
}
// Handle the result variable
child = node->first_node("data");
if (child)
{
attr = child->first_attribute("name");
if (attr)
mVariable = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mVariable, attr->value());
}
// Retrieve the line height
gr_getFontDetails(mFont ? mFont->GetResource() : NULL, &mFontHeight, NULL);
mLineHeight = mFontHeight;
if (mFolderIcon && mFolderIcon->GetResource())
{
if (gr_get_height(mFolderIcon->GetResource()) > mLineHeight)
mLineHeight = gr_get_width(mFolderIcon->GetResource());
mIconWidth = gr_get_width(mFolderIcon->GetResource());
mIconHeight = gr_get_height(mFolderIcon->GetResource());
}
if (mFileIcon && mFileIcon->GetResource())
{
if (gr_get_height(mFileIcon->GetResource()) > mLineHeight)
mLineHeight = gr_get_width(mFileIcon->GetResource());
mIconWidth = gr_get_width(mFileIcon->GetResource());
mIconHeight = gr_get_height(mFileIcon->GetResource());
}
if (mBackground && mBackground->GetResource())
{
mBackgroundW = gr_get_width(mBackground->GetResource());
mBackgroundH = gr_get_height(mBackground->GetResource());
}
// Fetch the file/folder list
std::string value;
DataManager::GetValue(mPathVar, value);
if (GetFileList(value) != 0 && (mShowNavFolders != 0 || mShowFiles != 0))
GetFileList("/sdcard");
}
