1 files changed, 398 insertions, 0 deletions

diff --git a/gui/console.cpp b/gui/console.cpp
new file mode 100644
index 000000000..6d53ed101
--- /dev/null
+++ b/gui/console.cpp
@@ -0,0 +1,398 @@
+// console.cpp - GUIConsole object
+
+#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"
+
+
+static std::vector<std::string> gConsole;
+
+extern "C" void gui_print(const char *fmt, ...)
+{
+    char buf[512];          // We're going to limit a single request to 512 bytes
+
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(buf, 512, fmt, ap);
+    va_end(ap);
+
+    char *start, *next;
+
+	if (buf[0] == '\n' && strlen(buf) < 2) {
+		// This prevents the double lines bug seen in the console during zip installs
+		return;
+	}
+
+    for (start = next = buf; *next != '\0'; next++)
+    {
+        if (*next == '\n')
+        {
+            *next = '\0';
+            next++;
+
+            std::string line = start;
+            gConsole.push_back(line);
+            start = next;
+
+			// Handle the normal \n\0 case
+            if (*next == '\0')
+				return;
+        }
+    }
+    std::string line = start;
+    gConsole.push_back(line);
+    return;
+}
+
+extern "C" void gui_print_overwrite(const char *fmt, ...)
+{
+    char buf[512];          // We're going to limit a single request to 512 bytes
+
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(buf, 512, fmt, ap);
+    va_end(ap);
+
+    // Pop the last line, and we can continue
+    if (!gConsole.empty())   gConsole.pop_back();
+
+    char *start, *next;
+    for (start = next = buf; *next != '\0'; next++)
+    {
+        if (*next == '\n')
+        {
+            *next = '\0';
+            next++;
+            
+            std::string line = start;
+            gConsole.push_back(line);
+            start = next;
+
+            // Handle the normal \n\0 case
+            if (*next == '\0')
+				return;
+        }
+    }
+    std::string line = start;
+    gConsole.push_back(line);
+    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, &mFontHeight, NULL);
+    SetActionPos(mRenderX, mRenderY, mRenderW, mRenderH);
+    SetRenderPos(mConsoleX, mConsoleY);
+    return;
+}
+
+int GUIConsole::RenderSlideout(void)
+{
+    if (!mSlideoutImage || !mSlideoutImage->GetResource())      return -1;
+
+    gr_blit(mSlideoutImage->GetResource(), 0, 0, mSlideoutW, mSlideoutH, mSlideoutX, mSlideoutY);
+    return 0;
+}
+
+int GUIConsole::RenderConsole(void)
+{
+    void* fontResource = NULL;
+    if (mFont)  fontResource = mFont->GetResource();
+
+    // We fill the background
+    gr_color(mBackgroundColor.red, mBackgroundColor.green, mBackgroundColor.blue, 255);
+    gr_fill(mConsoleX, mConsoleY, mConsoleW, mConsoleH);
+
+    gr_color(mScrollColor.red, mScrollColor.green, mScrollColor.blue, mScrollColor.alpha);
+    gr_fill(mConsoleX + (mConsoleW * 9 / 10), mConsoleY, (mConsoleW / 10), mConsoleH);
+
+    // Render the lines
+    gr_color(mForegroundColor.red, mForegroundColor.green, mForegroundColor.blue, mForegroundColor.alpha);
+
+    // Don't try to continue to render without data
+    mLastCount = gConsole.size();
+    if (mLastCount == 0)        return (mSlideout ? RenderSlideout() : 0);
+
+    // Find the start point
+    int start;
+    int curLine = mCurrentLine;    // Thread-safing (Another thread updates this value)
+    if (curLine == -1)
+    {
+        start = mLastCount - mMaxRows;
+    }
+    else
+    {
+        if (curLine > (int) mLastCount)   curLine = (int) mLastCount;
+        if ((int) mMaxRows > curLine)     curLine = (int) mMaxRows;
+        start = curLine - mMaxRows;
+    }
+
+    unsigned int line;
+    for (line = 0; line < mMaxRows; line++)
+    {
+        if ((start + (int) line) >= 0 && (start + (int) line) < (int) mLastCount)
+        {
+            gr_textExW(mConsoleX, mStartY + (line * mFontHeight), gConsole[start + line].c_str(), fontResource, mConsoleW + mConsoleX);
+        }
+    }
+    return (mSlideout ? RenderSlideout() : 0);
+}
+
+int GUIConsole::Render(void)
+{
+    if (mSlideout && mSlideoutState == hidden)
+    {
+        return RenderSlideout();
+    }
+    return RenderConsole();
+}
+
+int GUIConsole::Update(void)
+{
+    if (mSlideout && mSlideoutState != visible)
+    {
+        if (mSlideoutState == hidden)
+            return 0;
+
+        if (mSlideoutState == request_hide)
+            mSlideoutState = hidden;
+
+        if (mSlideoutState == request_show)
+            mSlideoutState = visible;
+
+        // Any time we activate the slider, we reset the position
+        mCurrentLine = -1;
+        return 2;
+    }
+
+    if (mCurrentLine == -1 && mLastCount != gConsole.size())
+    {
+        // We can use Render, and return for just a flip
+        Render();
+        return 2;
+    }
+    else if (mLastTouchY >= 0)
+    {
+        // They're still touching, so re-render
+        Render();
+        return 2;
+    }
+    return 0;
+}
+
+int GUIConsole::SetRenderPos(int x, int y, int w, int h)
+{
+    // Adjust the stub position accordingly
+    mSlideoutX += (x - mConsoleX);
+    mSlideoutY += (y - mConsoleY);
+
+    mConsoleX = x;
+    mConsoleY = y;
+    if (w || h)
+    {
+        mConsoleW = w;
+        mConsoleH = h;
+    }
+
+    // Calculate the max rows
+    mMaxRows = mConsoleH / mFontHeight;
+
+    // Adjust so we always fit to bottom
+    mStartY = mConsoleY + (mConsoleH % mFontHeight);
+    return 0;
+}
+
+// IsInRegion - Checks if the request is handled by this object
+//  Return 0 if this object handles the request, 1 if not
+int GUIConsole::IsInRegion(int x, int y)
+{
+    if (mSlideout)
+    {
+        // Check if they tapped the slideout button
+        if (x >= mSlideoutX && x <= mSlideoutX + mSlideoutW && y >= mSlideoutY && y < mSlideoutY + mSlideoutH)
+            return 1;
+
+        // If we're only rendering the slideout, bail now
+        if (mSlideoutState == hidden)
+            return 0;
+    }
+
+    return (x < mConsoleX || x > mConsoleX + mConsoleW || y < mConsoleY || y > mConsoleY + mConsoleH) ? 0 : 1;
+}
+
+// NotifyTouch - Notify of a touch event
+//  Return 0 on success, >0 to ignore remainder of touch, and <0 on error
+int GUIConsole::NotifyTouch(TOUCH_STATE state, int x, int y)
+{
+    if (mSlideout && mSlideoutState == hidden)
+    {
+        if (state == TOUCH_START)
+        {
+            mSlideoutState = request_show;
+            return 1;
+        }
+    }
+    else if (mSlideout && mSlideoutState == visible)
+    {
+        // Are we sliding it back in?
+        if (state == TOUCH_START && x > mSlideoutX && x < (mSlideoutX + mSlideoutW) && y > mSlideoutY && y < (mSlideoutY + mSlideoutH))
+        {
+            mSlideoutState = request_hide;
+            return 1;
+        }
+    }
+
+    // If we don't have enough lines to scroll, throw this away.
+    if (mLastCount < mMaxRows)   return 1;
+
+    // We are scrolling!!!
+    switch (state)
+    {
+    case TOUCH_START:
+        mLastTouchX = x;
+        mLastTouchY = y;
+        if ((x - mConsoleX) > ((9 * mConsoleW) / 10))
+            mSlideMultiplier = 10;
+        else
+            mSlideMultiplier = 1;
+        break;
+
+    case TOUCH_DRAG:
+        // This handles tapping
+        if (x == mLastTouchX && y == mLastTouchY)   break;
+        mLastTouchX = -1;
+
+        if (y > mLastTouchY + 5)
+        {
+            mLastTouchY = y;
+            if (mCurrentLine == -1)
+                mCurrentLine = mLastCount - mMaxRows;
+            else if (mCurrentLine > mSlideMultiplier)
+                mCurrentLine -= mSlideMultiplier;
+            else
+                mCurrentLine = mMaxRows;
+
+            if (mCurrentLine < (int) mMaxRows)
+                mCurrentLine = mMaxRows;
+        }
+        else if (y < mLastTouchY - 5)
+        {
+            mLastTouchY = y;
+            if (mCurrentLine >= 0)
+            {
+                mCurrentLine += mSlideMultiplier;
+                if (mCurrentLine >= (int) mLastCount)
+                    mCurrentLine = -1;
+            }
+        }
+        break;
+
+    case TOUCH_RELEASE:
+        // On a tap, we jump to the tail
+        if (mLastTouchX >= 0)
+            mCurrentLine = -1;
+
+        mLastTouchY = -1;
+	case TOUCH_REPEAT:
+	case TOUCH_HOLD:
+        break;
+    }
+    return 0;
+}
+