GUICheckbox::GUICheckbox(xml_node<>* node)
: Conditional(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mChecked = NULL;
mUnchecked = NULL;
mLabel = NULL;
mRendered = false;
mLastState = 0;
if (!node) return;
// The label can be loaded directly
mLabel = new GUIText(node);
// Read the check states
child = node->first_node("image");
if (child)
{
attr = child->first_attribute("checked");
if (attr)
mChecked = PageManager::FindResource(attr->value());
attr = child->first_attribute("unchecked");
if (attr)
mUnchecked = PageManager::FindResource(attr->value());
}
// Get the variable data
child = node->first_node("data");
if (child)
{
attr = child->first_attribute("variable");
if (attr)
mVarName = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mVarName, attr->value());
}
mCheckW = 0; mCheckH = 0;
if (mChecked && mChecked->GetResource())
{
mCheckW = gr_get_width(mChecked->GetResource());
mCheckH = gr_get_height(mChecked->GetResource());
}
else if (mUnchecked && mUnchecked->GetResource())
{
mCheckW = gr_get_width(mUnchecked->GetResource());
mCheckH = gr_get_height(mUnchecked->GetResource());
}
int x, y, w, h;
mLabel->GetRenderPos(x, y, w, h);
SetRenderPos(x, y, 0, 0);
return;
}
GUICheckbox::GUICheckbox(xml_node<>* node)
: GUIObject(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mChecked = NULL;
mUnchecked = NULL;
mLabel = NULL;
mRendered = false;
mLastState = 0;
if (!node)
return;
// The label can be loaded directly
mLabel = new GUIText(node);
// Read the check states
child = FindNode(node, "image");
if (child)
{
mChecked = LoadAttrImage(child, "checked");
mUnchecked = LoadAttrImage(child, "unchecked");
}
// Get the variable data
child = FindNode(node, "data");
if (child)
{
attr = child->first_attribute("variable");
if (attr)
mVarName = attr->value();
attr = child->first_attribute("default");
if (attr)
DataManager::SetValue(mVarName, attr->value());
}
mCheckW = mChecked->GetWidth();
mCheckH = mChecked->GetHeight();
if (mCheckW == 0)
{
mCheckW = mUnchecked->GetWidth();
mCheckH = mUnchecked->GetHeight();
}
int x, y, w, h;
mLabel->GetRenderPos(x, y, w, h);
SetRenderPos(x, y, 0, 0);
}
GUIButton::GUIButton(xml_node<>* node)
: Conditional(node)
{
xml_attribute<>* attr;
xml_node<>* child;
mButtonImg = NULL;
mButtonIcon = NULL;
mButtonLabel = NULL;
mAction = NULL;
mRendered = 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)
{
LOGE("Unable to locate button image\n");
delete mButtonImg;
mButtonImg = NULL;
}
if (mButtonLabel->Render() < 0)
{
delete mButtonLabel;
mButtonLabel = NULL;
}
// 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());
}
int x, y, w, h;
if (mButtonImg) mButtonImg->GetRenderPos(x, y, w, h);
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;
}
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);
}
}
}
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);
}
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;
}
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;
}
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;
}
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;
}
