1 files changed, 892 insertions, 0 deletions

diff --git a/gui/pages.cpp b/gui/pages.cpp
new file mode 100644
index 000000000..7e9274def
--- /dev/null
+++ b/gui/pages.cpp
@@ -0,0 +1,892 @@
+// base_objects.cpp - Source to manage GUI base objects
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/reboot.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include <string>
+
+extern "C" {
+#include "../common.h"
+#include "../minuitwrp/minui.h"
+#include "../recovery_ui.h"
+}
+
+#include "rapidxml.hpp"
+#include "objects.hpp"
+
+extern int gGuiRunning;
+
+std::map<std::string, PageSet*> PageManager::mPageSets;
+PageSet* PageManager::mCurrentSet;
+PageSet* PageManager::mBaseSet = NULL;
+
+
+// Helper routine to convert a string to a color declaration
+int ConvertStrToColor(std::string str, COLOR* color)
+{
+    // Set the default, solid black
+    memset(color, 0, sizeof(COLOR));
+    color->alpha = 255;
+
+    // Translate variables
+    DataManager::GetValue(str, str);
+    
+    // Look for some defaults
+    if (str == "black")         return 0;
+    else if (str == "white")    { color->red = color->green = color->blue = 255; return 0; }
+    else if (str == "red")      { color->red = 255; return 0; }
+    else if (str == "green")    { color->green = 255; return 0; }
+    else if (str == "blue")     { color->blue = 255; return 0; }
+
+    // At this point, we require an RGB(A) color
+    if (str[0] != '#')          return -1;
+    str.erase(0, 1);
+
+    int result = strtol(str.c_str(), NULL, 16);
+    if (str.size() > 6)
+    {
+        // We have alpha channel
+        color->alpha = result & 0x000000FF;
+        result = result >> 8;
+    }
+    color->red = (result >> 16) & 0x000000FF;
+    color->green = (result >> 8) & 0x000000FF;
+    color->blue = result & 0x000000FF;
+    return 0;
+}
+
+// Helper APIs
+bool LoadPlacement(xml_node<>* node, int* x, int* y, int* w /* = NULL */, int* h /* = NULL */, RenderObject::Placement* placement /* = NULL */)
+{
+    if (!node)      return false;
+
+    std::string value;
+    if (node->first_attribute("x"))
+    {
+        value = node->first_attribute("x")->value();
+        DataManager::GetValue(value, value);
+        *x = atol(value.c_str());
+    }
+
+    if (node->first_attribute("y"))
+    {
+        value = node->first_attribute("y")->value();
+        DataManager::GetValue(value, value);
+        *y = atol(value.c_str());
+    }
+
+    if (w && node->first_attribute("w"))
+    {
+        value = node->first_attribute("w")->value();
+        DataManager::GetValue(value, value);
+        *w = atol(value.c_str());
+    }
+
+    if (h && node->first_attribute("h"))
+    {
+        value = node->first_attribute("h")->value();
+        DataManager::GetValue(value, value);
+        *h = atol(value.c_str());
+    }
+
+    if (placement && node->first_attribute("placement"))
+    {
+        value = node->first_attribute("placement")->value();
+        DataManager::GetValue(value, value);
+        *placement = (RenderObject::Placement) atol(value.c_str());
+    }
+
+    return true;
+}
+
+int ActionObject::SetActionPos(int x, int y, int w, int h)
+{
+    if (x < 0 || y < 0)                                     return -1;
+
+    mActionX = x; 
+    mActionY = y; 
+    if (w || h)
+    {
+        mActionW = w;
+        mActionH = h;
+    }
+    return 0;
+}
+
+Page::Page(xml_node<>* page, xml_node<>* templates /* = NULL */)
+{
+    mTouchStart = NULL;
+
+    // We can memset the whole structure, because the alpha channel is ignored
+    memset(&mBackground, 0, sizeof(COLOR));
+
+    // With NULL, we make a console-only display
+    if (!page)
+    {
+        mName = "console";
+
+        GUIConsole* element = new GUIConsole(NULL);
+        mRenders.push_back(element);
+        mActions.push_back(element);
+        return;
+    }
+
+    if (page->first_attribute("name"))
+        mName = page->first_attribute("name")->value();
+    else
+    {
+        LOGE("No page name attribute found!\n");
+        return;
+    }
+
+    LOGI("Loading page %s\n", mName.c_str());
+
+    // This is a recursive routine for template handling
+    ProcessNode(page, templates);
+
+    return;
+}
+
+bool Page::ProcessNode(xml_node<>* page, xml_node<>* templates /* = NULL */, int depth /* = 0 */)
+{
+    if (depth == 10)
+    {
+        LOGE("Page processing depth has exceeded 10. Failing out. This is likely a recursive template.\n");
+        return false;
+    }
+
+    // Let's retrieve the background value, if any
+    xml_node<>* bg = page->first_node("background");
+    if (bg)
+    {
+        xml_attribute<>* attr = bg->first_attribute("color");
+        if (attr)
+        {
+            std::string color = attr->value();
+            ConvertStrToColor(color, &mBackground);
+        }
+    }
+
+    xml_node<>* child;
+    child = page->first_node("object");
+    while (child)
+    {
+        if (!child->first_attribute("type"))
+            break;
+
+        std::string type = child->first_attribute("type")->value();
+
+        if (type == "text")
+        {
+            GUIText* element = new GUIText(child);
+            mRenders.push_back(element);
+            mActions.push_back(element);
+        }
+        else if (type == "image")
+        {
+            GUIImage* element = new GUIImage(child);
+            mRenders.push_back(element);
+        }
+        else if (type == "fill")
+        {
+            GUIFill* element = new GUIFill(child);
+            mRenders.push_back(element);
+        }
+        else if (type == "action")
+        {
+            GUIAction* element = new GUIAction(child);
+            mActions.push_back(element);
+        }
+        else if (type == "console")
+        {
+            GUIConsole* element = new GUIConsole(child);
+            mRenders.push_back(element);
+            mActions.push_back(element);
+        }
+        else if (type == "button")
+        {
+            GUIButton* element = new GUIButton(child);
+            mRenders.push_back(element);
+            mActions.push_back(element);
+        }
+        else if (type == "checkbox")
+        {
+            GUICheckbox* element = new GUICheckbox(child);
+            mRenders.push_back(element);
+            mActions.push_back(element);
+        }
+        else if (type == "fileselector")
+        {
+            GUIFileSelector* element = new GUIFileSelector(child);
+            mRenders.push_back(element);
+            mActions.push_back(element);
+        }
+        else if (type == "animation")
+        {
+            GUIAnimation* element = new GUIAnimation(child);
+            mRenders.push_back(element);
+        }
+        else if (type == "progressbar")
+        {
+            GUIProgressBar* element = new GUIProgressBar(child);
+            mRenders.push_back(element);
+            mActions.push_back(element);
+        }
+		else if (type == "slider")
+        {
+            GUISlider* element = new GUISlider(child);
+            mRenders.push_back(element);
+            mActions.push_back(element);
+        }
+		else if (type == "listbox")
+		{
+			GUIListBox* element = new GUIListBox(child);
+			mRenders.push_back(element);
+			mActions.push_back(element);
+		}
+		else if (type == "keyboard")
+		{
+			GUIKeyboard* element = new GUIKeyboard(child);
+			mRenders.push_back(element);
+			mActions.push_back(element);
+		}
+		else if (type == "input")
+		{
+			GUIInput* element = new GUIInput(child);
+			mRenders.push_back(element);
+			mActions.push_back(element);
+			mInputs.push_back(element);
+		}
+        else if (type == "template")
+        {
+            if (!templates || !child->first_attribute("name"))
+            {
+                LOGE("Invalid template request.\n");
+            }
+            else
+            {
+                std::string name = child->first_attribute("name")->value();
+
+                // We need to find the correct template
+                xml_node<>* node;
+                node = templates->first_node("template");
+
+                while (node)
+                {
+                    if (!node->first_attribute("name"))
+                        continue;
+
+                    if (name == node->first_attribute("name")->value())
+                    {
+                        if (!ProcessNode(node, templates, depth + 1))
+                            return false;
+                        else
+                            break;
+                    }
+                    node = node->next_sibling("template");
+                }
+            }
+        }
+        else
+        {
+            LOGE("Unknown object type.\n");
+        }
+        child = child->next_sibling("object");
+    }
+    return true;
+}
+
+int Page::Render(void)
+{
+    // Render background
+    gr_color(mBackground.red, mBackground.green, mBackground.blue, mBackground.alpha);
+    gr_fill(0, 0, gr_fb_width(), gr_fb_height());
+
+    // Render remaining objects
+    std::vector<RenderObject*>::iterator iter;
+    for (iter = mRenders.begin(); iter != mRenders.end(); iter++)
+    {
+        if ((*iter)->Render())
+            LOGE("A render request has failed.\n");
+    }
+    return 0;
+}
+
+int Page::Update(void)
+{
+    int retCode = 0;
+
+    std::vector<RenderObject*>::iterator iter;
+    for (iter = mRenders.begin(); iter != mRenders.end(); iter++)
+    {
+        int ret = (*iter)->Update();
+        if (ret < 0)
+            LOGE("An update request has failed.\n");
+        else if (ret > retCode)
+            retCode = ret;
+    }
+
+    return retCode;
+}
+
+int Page::NotifyTouch(TOUCH_STATE state, int x, int y)
+{
+    // By default, return 1 to ignore further touches if nobody is listening
+    int ret = 1;
+
+    // Don't try to handle a lack of handlers
+    if (mActions.size() == 0)   return ret;
+
+    // We record mTouchStart so we can pass all the touch stream to the same handler
+    if (state == TOUCH_START)
+    {
+        std::vector<ActionObject*>::reverse_iterator iter;
+        // We work backwards, from top-most element to bottom-most element
+        for (iter = mActions.rbegin(); iter != mActions.rend(); iter++)
+        {
+            if ((*iter)->IsInRegion(x, y))
+            {
+                mTouchStart = (*iter);
+                ret = mTouchStart->NotifyTouch(state, x, y);
+                if (ret >= 0)   break;
+                mTouchStart = NULL;
+            }
+        }
+    }
+    else if (state == TOUCH_RELEASE && mTouchStart != NULL)
+    {
+        ret = mTouchStart->NotifyTouch(state, x, y);
+        mTouchStart = NULL;
+    }
+    else if ((state == TOUCH_DRAG || state == TOUCH_HOLD || state == TOUCH_REPEAT) && mTouchStart != NULL)
+    {
+        ret = mTouchStart->NotifyTouch(state, x, y);
+    }
+    return ret;
+}
+
+int Page::NotifyKey(int key)
+{
+    std::vector<ActionObject*>::reverse_iterator iter;
+
+    // Don't try to handle a lack of handlers
+    if (mActions.size() == 0)   return 1;
+
+    // We work backwards, from top-most element to bottom-most element
+    for (iter = mActions.rbegin(); iter != mActions.rend(); iter++)
+    {
+        int ret = (*iter)->NotifyKey(key);
+        if (ret == 0)
+            return 0;
+        else if (ret < 0)
+            LOGE("An action handler has returned an error");
+    }
+    return 1;
+}
+
+int Page::NotifyKeyboard(int key)
+{
+    std::vector<InputObject*>::reverse_iterator iter;
+
+    // Don't try to handle a lack of handlers
+    if (mInputs.size() == 0)   return 1;
+
+    // We work backwards, from top-most element to bottom-most element
+    for (iter = mInputs.rbegin(); iter != mInputs.rend(); iter++)
+    {
+        int ret = (*iter)->NotifyKeyboard(key);
+        if (ret == 0)
+            return 0;
+        else if (ret < 0)
+            LOGE("A keyboard handler has returned an error");
+    }
+    return 1;
+}
+
+int Page::SetKeyBoardFocus(int inFocus)
+{
+    std::vector<InputObject*>::reverse_iterator iter;
+
+    // Don't try to handle a lack of handlers
+    if (mInputs.size() == 0)   return 1;
+
+    // We work backwards, from top-most element to bottom-most element
+    for (iter = mInputs.rbegin(); iter != mInputs.rend(); iter++)
+    {
+        int ret = (*iter)->SetInputFocus(inFocus);
+        if (ret == 0)
+            return 0;
+        else if (ret < 0)
+            LOGE("An input focus handler has returned an error");
+    }
+    return 1;
+}
+
+void Page::SetPageFocus(int inFocus)
+{
+    // Render remaining objects
+    std::vector<RenderObject*>::iterator iter;
+    for (iter = mRenders.begin(); iter != mRenders.end(); iter++)
+    {
+        (*iter)->SetPageFocus(inFocus);
+    }
+    return;
+}
+
+int Page::NotifyVarChange(std::string varName, std::string value)
+{
+    std::vector<ActionObject*>::iterator iter;
+
+    // Don't try to handle a lack of handlers
+    if (mActions.size() == 0)   return 1;
+
+    for (iter = mActions.begin(); iter != mActions.end(); ++iter)
+    {
+        if ((*iter)->NotifyVarChange(varName, value))
+            LOGE("An action handler errored on NotifyVarChange.\n");
+    }
+    return 0;
+}
+
+PageSet::PageSet(char* xmlFile)
+{
+    mResources = NULL;
+    mCurrentPage = NULL;
+    mOverlayPage = NULL;
+
+    mXmlFile = xmlFile;
+    if (xmlFile)
+        mDoc.parse<0>(mXmlFile);
+    else
+        mCurrentPage = new Page(NULL);
+}
+
+PageSet::~PageSet()
+{
+    delete mResources;
+    free(mXmlFile);
+}
+
+int PageSet::Load(ZipArchive* package)
+{
+    xml_node<>* parent;
+    xml_node<>* child;
+    xml_node<>* templates;
+ 
+    parent = mDoc.first_node("recovery");
+    if (!parent)
+        parent = mDoc.first_node("install");
+
+    // Now, let's parse the XML
+    LOGI("Loading resources...\n");
+    child = parent->first_node("resources");
+    if (child)
+        mResources = new ResourceManager(child, package);
+
+    LOGI("Loading variables...\n");
+    child = parent->first_node("variables");
+    if (child)
+        LoadVariables(child);
+
+    LOGI("Loading pages...\n");
+    // This may be NULL if no templates are present
+    templates = parent->first_node("templates");
+
+    child = parent->first_node("pages");
+    if (!child)
+        return -1;
+
+    return LoadPages(child, templates);
+}
+
+int PageSet::SetPage(std::string page)
+{
+    Page* tmp = FindPage(page);
+    if (tmp)
+    {
+        if (mCurrentPage)   mCurrentPage->SetPageFocus(0);
+        mCurrentPage = tmp;
+        mCurrentPage->SetPageFocus(1);
+        mCurrentPage->NotifyVarChange("", "");
+        return 0;
+    }
+    else
+    {
+        LOGE("Unable to locate page (%s)\n", page.c_str());
+    }
+    return -1;
+}
+
+int PageSet::SetOverlay(Page* page)
+{
+    if (mOverlayPage)   mOverlayPage->SetPageFocus(0);
+    mOverlayPage = page;
+    if (mOverlayPage)
+    {
+        mOverlayPage->SetPageFocus(1);
+        mOverlayPage->NotifyVarChange("", "");
+    }
+    return 0;
+}
+
+Resource* PageSet::FindResource(std::string name)
+{
+    return mResources ? mResources->FindResource(name) : NULL;
+}
+
+Page* PageSet::FindPage(std::string name)
+{
+    std::vector<Page*>::iterator iter;
+
+    for (iter = mPages.begin(); iter != mPages.end(); iter++)
+    {
+        if (name == (*iter)->GetName())
+            return (*iter);
+    }
+    return NULL;
+}
+
+int PageSet::LoadVariables(xml_node<>* vars)
+{
+    xml_node<>* child;
+
+    child = vars->first_node("variable");
+    while (child)
+    {
+        if (!child->first_attribute("name"))
+            break;
+        if (!child->first_attribute("value"))
+            break;
+
+        DataManager::SetValue(child->first_attribute("name")->value(), child->first_attribute("value")->value());
+        child = child->next_sibling("variable");
+    }
+    return 0;
+}
+
+int PageSet::LoadPages(xml_node<>* pages, xml_node<>* templates /* = NULL */)
+{
+    xml_node<>* child;
+
+    if (!pages)    return -1;
+
+    child = pages->first_node("page");
+    while (child != NULL)
+    {
+        Page* page = new Page(child, templates);
+        if (page->GetName().empty())
+        {
+            LOGE("Unable to process load page\n");
+            delete page;
+        }
+        else
+        {
+            mPages.push_back(page);
+        }
+        child = child->next_sibling("page");
+    }
+    if (mPages.size() > 0)
+        return 0;
+    return -1;
+}
+
+int PageSet::IsCurrentPage(Page* page)
+{
+    return ((mCurrentPage && mCurrentPage == page) ? 1 : 0);
+}
+
+int PageSet::Render(void)
+{
+    int ret;
+
+    ret = (mCurrentPage ? mCurrentPage->Render() : -1);
+    if (ret < 0)    return ret;
+    ret = (mOverlayPage ? mOverlayPage->Render() : -1);
+    return ret;
+}
+
+int PageSet::Update(void)
+{
+    int ret;
+
+    ret = (mCurrentPage ? mCurrentPage->Update() : -1);
+    if (ret < 0 || ret > 1)     return ret;
+    ret = (mOverlayPage ? mOverlayPage->Update() : -1);
+    return ret;
+}
+
+int PageSet::NotifyTouch(TOUCH_STATE state, int x, int y)
+{
+    if (mOverlayPage)   return (mOverlayPage->NotifyTouch(state, x, y));
+    return (mCurrentPage ? mCurrentPage->NotifyTouch(state, x, y) : -1);
+}
+
+int PageSet::NotifyKey(int key)
+{
+    if (mOverlayPage)   return (mOverlayPage->NotifyKey(key));
+    return (mCurrentPage ? mCurrentPage->NotifyKey(key) : -1);
+}
+
+int PageSet::NotifyKeyboard(int key)
+{
+    if (mOverlayPage)   return (mOverlayPage->NotifyKeyboard(key));
+    return (mCurrentPage ? mCurrentPage->NotifyKeyboard(key) : -1);
+}
+
+int PageSet::SetKeyBoardFocus(int inFocus)
+{
+    if (mOverlayPage)   return (mOverlayPage->SetKeyBoardFocus(inFocus));
+    return (mCurrentPage ? mCurrentPage->SetKeyBoardFocus(inFocus) : -1);
+}
+
+int PageSet::NotifyVarChange(std::string varName, std::string value)
+{
+    if (mOverlayPage)   mOverlayPage->NotifyVarChange(varName, value);
+    return (mCurrentPage ? mCurrentPage->NotifyVarChange(varName, value) : -1);
+}
+
+int PageManager::LoadPackage(std::string name, std::string package, std::string startpage)
+{
+    int fd;
+    ZipArchive zip, *pZip = NULL;
+    long len;
+    char* xmlFile = NULL;
+    PageSet* pageSet = NULL;
+    int ret;
+
+    // Open the XML file
+    LOGI("Loading package: %s (%s)\n", name.c_str(), package.c_str());
+    if (mzOpenZipArchive(package.c_str(), &zip))
+    {
+        // We can try to load the XML directly...
+        struct stat st;
+        if(stat(package.c_str(),&st) != 0)
+            return -1;
+
+        len = st.st_size;
+        xmlFile = (char*) malloc(len + 1);
+        if (!xmlFile)       return -1;
+
+        fd = open(package.c_str(), O_RDONLY);
+        if (fd == -1)       goto error;
+
+        read(fd, xmlFile, len);
+        close(fd);
+    }
+    else
+    {
+        pZip = &zip;
+        const ZipEntry* ui_xml = mzFindZipEntry(&zip, "ui.xml");
+        if (ui_xml == NULL)
+        {
+            LOGE("Unable to locate ui.xml in zip file\n");
+            goto error;
+        }
+    
+        // Allocate the buffer for the file
+        len = mzGetZipEntryUncompLen(ui_xml);
+        xmlFile = (char*) malloc(len + 1);
+        if (!xmlFile)        goto error;
+    
+        if (!mzExtractZipEntryToBuffer(&zip, ui_xml, (unsigned char*) xmlFile))
+        {
+            LOGE("Unable to extract ui.xml\n");
+            goto error;
+        }
+    }
+
+    // NULL-terminate the string
+    xmlFile[len] = 0x00;
+
+    // Before loading, mCurrentSet must be the loading package so we can find resources
+    pageSet = mCurrentSet;
+    mCurrentSet = new PageSet(xmlFile);
+
+    ret = mCurrentSet->Load(pZip);
+    if (ret == 0)
+    {
+        mCurrentSet->SetPage(startpage);
+        mPageSets.insert(std::pair<std::string, PageSet*>(name, mCurrentSet));
+    }
+    else
+    {
+        LOGE("Package %s failed to load.\n", name.c_str());
+    }
+	
+    // The first successful package we loaded is the base
+    if (mBaseSet == NULL)
+        mBaseSet = mCurrentSet;
+
+    mCurrentSet = pageSet;
+
+    if (pZip)   mzCloseZipArchive(pZip);
+    return ret;
+
+error:
+    LOGE("An internal error has occurred.\n");
+    if (pZip)       mzCloseZipArchive(pZip);
+    if (xmlFile)    free(xmlFile);
+    return -1;
+}
+
+PageSet* PageManager::FindPackage(std::string name)
+{
+    std::map<std::string, PageSet*>::iterator iter;
+
+    iter = mPageSets.find(name);
+    if (iter != mPageSets.end())
+    {
+        return (*iter).second;
+    }
+    LOGE("Unable to locate package %s\n", name.c_str());
+    return NULL;
+}
+
+PageSet* PageManager::SelectPackage(std::string name)
+{
+    LOGI("Switching packages (%s)\n", name.c_str());
+    PageSet* tmp;
+
+    tmp = FindPackage(name);
+    if (tmp)
+        mCurrentSet = tmp;
+    else
+        LOGE("Unable to find package.\n");
+
+    return mCurrentSet;
+}
+
+int PageManager::ReloadPackage(std::string name, std::string package)
+{
+    std::map<std::string, PageSet*>::iterator iter;
+
+    iter = mPageSets.find(name);
+    if (iter == mPageSets.end())
+        return -1;
+
+    PageSet* set = (*iter).second;
+    mPageSets.erase(iter);
+
+    if (LoadPackage(name, package, "main") != 0)
+    {
+        LOGE("Failed to load package.\n");
+        mPageSets.insert(std::pair<std::string, PageSet*>(name, set));
+        return -1;
+    }
+    if (mCurrentSet == set)     SelectPackage(name);
+    delete set;
+    return 0;
+}
+
+void PageManager::ReleasePackage(std::string name)
+{
+    std::map<std::string, PageSet*>::iterator iter;
+
+    iter = mPageSets.find(name);
+    if (iter == mPageSets.end())
+        return;
+
+    PageSet* set = (*iter).second;
+    mPageSets.erase(iter);
+    delete set;
+    return;
+}
+
+int PageManager::ChangePage(std::string name)
+{
+    DataManager::SetValue("tw_operation_state", 0);
+    int ret = (mCurrentSet ? mCurrentSet->SetPage(name) : -1);
+    return ret;
+}
+
+int PageManager::ChangeOverlay(std::string name)
+{
+    if (name.empty())
+        return mCurrentSet->SetOverlay(NULL);
+    else
+    {
+        Page* page = mBaseSet ? mBaseSet->FindPage(name) : NULL;
+        return mCurrentSet->SetOverlay(page);
+    }
+}
+
+Resource* PageManager::FindResource(std::string name)
+{
+    return (mCurrentSet ? mCurrentSet->FindResource(name) : NULL);
+}
+
+Resource* PageManager::FindResource(std::string package, std::string name)
+{
+    PageSet* tmp;
+
+    tmp = FindPackage(name);
+    return (tmp ? tmp->FindResource(name) : NULL);
+}
+
+int PageManager::SwitchToConsole(void)
+{
+    PageSet* console = new PageSet(NULL);
+
+    mCurrentSet = console;
+    return 0;
+}
+
+int PageManager::IsCurrentPage(Page* page)
+{
+    return (mCurrentSet ? mCurrentSet->IsCurrentPage(page) : 0);
+}
+
+int PageManager::Render(void)
+{
+    return (mCurrentSet ? mCurrentSet->Render() : -1);
+}
+
+int PageManager::Update(void)
+{
+    return (mCurrentSet ? mCurrentSet->Update() : -1);
+}
+
+int PageManager::NotifyTouch(TOUCH_STATE state, int x, int y)
+{
+    return (mCurrentSet ? mCurrentSet->NotifyTouch(state, x, y) : -1);
+}
+
+int PageManager::NotifyKey(int key)
+{
+    return (mCurrentSet ? mCurrentSet->NotifyKey(key) : -1);
+}
+
+int PageManager::NotifyKeyboard(int key)
+{
+    return (mCurrentSet ? mCurrentSet->NotifyKeyboard(key) : -1);
+}
+
+int PageManager::SetKeyBoardFocus(int inFocus)
+{
+    return (mCurrentSet ? mCurrentSet->SetKeyBoardFocus(inFocus) : -1);
+}
+
+int PageManager::NotifyVarChange(std::string varName, std::string value)
+{
+    return (mCurrentSet ? mCurrentSet->NotifyVarChange(varName, value) : -1);
+}
+
+extern "C" void gui_notifyVarChange(const char *name, const char* value)
+{
+    if (!gGuiRunning)   return;
+
+    PageManager::NotifyVarChange(name, value);
+}
+