diff --git a/gui/gui.cpp b/gui/gui.cpp
new file mode 100644
index 0000000..cb2b7c1
--- /dev/null
+++ b/gui/gui.cpp
@@ -0,0 +1,629 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <linux/input.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <errno.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 <sys/mount.h>
+#include <time.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+
+extern "C" {
+#include "../common.h"
+#include "../roots.h"
+#include "../minuitwrp/minui.h"
+#include "../recovery_ui.h"
+#include "../minzip/Zip.h"
+#include <pixelflinger/pixelflinger.h>
+}
+
+#include "rapidxml.hpp"
+#include "objects.hpp"
+#include "../data.hpp"
+#include "../variables.h"
+
+#include "curtain.h"
+
+const static int CURTAIN_FADE = 32;
+
+using namespace rapidxml;
+
+// Global values
+static gr_surface gCurtain = NULL;
+static int gGuiInitialized = 0;
+static int gGuiConsoleRunning = 0;
+static int gGuiConsoleTerminate = 0;
+static int gForceRender = 0;
+static int gNoAnimation = 0;
+
+// Needed by pages.cpp too
+int gGuiRunning = 0;
+
+static int gRecorder = -1;
+
+extern "C" void gr_write_frame_to_file(int fd);
+
+void flip(void)
+{
+    if (gRecorder != -1)
+    {
+        timespec time;
+        clock_gettime(CLOCK_MONOTONIC, &time);
+        write(gRecorder, &time, sizeof(timespec));
+        gr_write_frame_to_file(gRecorder);
+    }
+    gr_flip();
+    return;
+}
+
+void rapidxml::parse_error_handler(const char *what, void *where)
+{
+    fprintf(stderr, "Parser error: %s\n", what);
+    fprintf(stderr, "  Start of string: %s\n", (char*) where);
+    abort();
+}
+
+static void curtainSet()
+{
+    gr_color(0, 0, 0, 255);
+    gr_fill(0, 0, gr_fb_width(), gr_fb_height());
+    gr_blit(gCurtain, 0, 0, gr_get_width(gCurtain), gr_get_height(gCurtain), 0, 0);
+    gr_flip();
+    return;
+}
+
+static void curtainRaise(gr_surface surface)
+{
+	int sy = 0;
+    int h = gr_get_height(gCurtain) - 1;
+    int w = gr_get_width(gCurtain);
+    int fy = 1;
+
+    int msw = gr_get_width(surface);
+    int msh = gr_get_height(surface);
+	int CURTAIN_RATE = msh / 30;
+
+    if (gNoAnimation == 0)
+    {
+        for (; h > 0; h -= CURTAIN_RATE, sy += CURTAIN_RATE, fy += CURTAIN_RATE)
+        {
+            gr_blit(surface, 0, 0, msw, msh, 0, 0);
+            gr_blit(gCurtain, 0, sy, w, h, 0, 0);
+            gr_flip();
+        }
+    }
+    gr_blit(surface, 0, 0, msw, msh, 0, 0);
+    flip();
+    return;
+}
+
+void curtainClose()
+{
+#if 0
+    int w = gr_get_width(gCurtain);
+    int h = 1;
+    int sy = gr_get_height(gCurtain) - 1;
+    int fbh = gr_fb_height();
+	int CURTAIN_RATE = fbh / 30;
+
+    if (gNoAnimation == 0)
+    {
+        for (; h < fbh; h += CURTAIN_RATE, sy -= CURTAIN_RATE)
+        {
+            gr_blit(gCurtain, 0, sy, w, h, 0, 0);
+            gr_flip();
+        }
+        gr_blit(gCurtain, 0, 0, gr_get_width(gCurtain), gr_get_height(gCurtain), 0, 0);
+        gr_flip();
+
+        if (gRecorder != -1)
+            close(gRecorder);
+
+        int fade;
+        for (fade = 16; fade < 255; fade += CURTAIN_FADE)
+        {
+            gr_blit(gCurtain, 0, 0, gr_get_width(gCurtain), gr_get_height(gCurtain), 0, 0);
+            gr_color(0, 0, 0, fade);
+            gr_fill(0, 0, gr_fb_width(), gr_fb_height());
+            gr_flip();
+        }
+        gr_color(0, 0, 0, 255);
+        gr_fill(0, 0, gr_fb_width(), gr_fb_height());
+        gr_flip();
+    }
+#else
+    gr_blit(gCurtain, 0, 0, gr_get_width(gCurtain), gr_get_height(gCurtain), 0, 0);
+    gr_flip();
+#endif
+    return;
+}
+
+timespec timespec_diff(timespec& start, timespec& end)
+{
+	timespec temp;
+	if ((end.tv_nsec-start.tv_nsec)<0) {
+		temp.tv_sec = end.tv_sec-start.tv_sec-1;
+		temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
+	} else {
+		temp.tv_sec = end.tv_sec-start.tv_sec;
+		temp.tv_nsec = end.tv_nsec-start.tv_nsec;
+	}
+	return temp;
+}
+
+static void *input_thread(void *cookie)
+{
+    int drag = 0;
+	static int touch_and_hold = 0, dontwait = 0, touch_repeat = 0, x = 0, y = 0, lshift = 0, rshift = 0, key_repeat = 0;
+	static struct timeval touchStart;
+	HardwareKeyboard kb;
+
+    for (;;) {
+
+        // wait for the next event
+        struct input_event ev;
+        int state = 0, ret = 0;
+
+		ret = ev_get(&ev, dontwait);
+
+		if (ret < 0) {
+			struct timeval curTime;
+			gettimeofday(&curTime, NULL);
+			long mtime, seconds, useconds;
+
+			seconds  = curTime.tv_sec  - touchStart.tv_sec;
+			useconds = curTime.tv_usec - touchStart.tv_usec;
+
+			mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;
+			if (touch_and_hold && mtime > 500) {
+				touch_and_hold = 0;
+				touch_repeat = 1;
+				gettimeofday(&touchStart, NULL);
+#ifdef _EVENT_LOGGING
+                LOGE("TOUCH_HOLD: %d,%d\n", x, y);
+#endif
+				PageManager::NotifyTouch(TOUCH_HOLD, x, y);
+			} else if (touch_repeat && mtime > 100) {
+#ifdef _EVENT_LOGGING
+                LOGE("TOUCH_REPEAT: %d,%d\n", x, y);
+#endif
+				gettimeofday(&touchStart, NULL);
+				PageManager::NotifyTouch(TOUCH_REPEAT, x, y);
+			} else if (key_repeat == 1 && mtime > 500) {
+#ifdef _EVENT_LOGGING
+                LOGE("KEY_HOLD: %d,%d\n", x, y);
+#endif
+				gettimeofday(&touchStart, NULL);
+				key_repeat = 2;
+				kb.KeyRepeat();
+			} else if (key_repeat == 2 && mtime > 100) {
+#ifdef _EVENT_LOGGING
+                LOGE("KEY_REPEAT: %d,%d\n", x, y);
+#endif
+				gettimeofday(&touchStart, NULL);
+				kb.KeyRepeat();
+			}
+		} else if (ev.type == EV_ABS) {
+
+            x = ev.value >> 16;
+            y = ev.value & 0xFFFF;
+
+            if (ev.code == 0)
+            {
+                if (state == 0)
+                {
+#ifdef _EVENT_LOGGING
+                    LOGE("TOUCH_RELEASE: %d,%d\n", x, y);
+#endif
+                    PageManager::NotifyTouch(TOUCH_RELEASE, x, y);
+					touch_and_hold = 0;
+					touch_repeat = 0;
+					if (!key_repeat)
+						dontwait = 0;
+                }
+                state = 0;
+                drag = 0;
+            }
+            else
+            {
+                if (!drag)
+                {
+#ifdef _EVENT_LOGGING
+                    LOGE("TOUCH_START: %d,%d\n", x, y);
+#endif
+                    if (PageManager::NotifyTouch(TOUCH_START, x, y) > 0)
+                        state = 1;
+                    drag = 1;
+					touch_and_hold = 1;
+					dontwait = 1;
+					key_repeat = 0;
+					gettimeofday(&touchStart, NULL);
+                }
+                else
+                {
+                    if (state == 0)
+                    {
+#ifdef _EVENT_LOGGING
+                        LOGE("TOUCH_DRAG: %d,%d\n", x, y);
+#endif
+                        if (PageManager::NotifyTouch(TOUCH_DRAG, x, y) > 0)
+                            state = 1;
+						key_repeat = 0;
+                    }
+                }
+            }
+        }
+        else if (ev.type == EV_KEY)
+        {
+            // Handle key-press here
+#ifdef _EVENT_LOGGING
+            LOGE("TOUCH_KEY: %d\n", ev.code);
+#endif
+			if (ev.value != 0) {
+				// This is a key press
+				if (kb.KeyDown(ev.code)) {
+					key_repeat = 1;
+					touch_and_hold = 0;
+					touch_repeat = 0;
+					dontwait = 1;
+					gettimeofday(&touchStart, NULL);
+				} else {
+					key_repeat = 0;
+					touch_and_hold = 0;
+					touch_repeat = 0;
+					dontwait = 0;
+				}
+			} else {
+				// This is a key release
+				kb.KeyUp(ev.code);
+				key_repeat = 0;
+				touch_and_hold = 0;
+				touch_repeat = 0;
+				dontwait = 0;
+			}
+        }
+    }
+    return NULL;
+}
+
+// This special function will return immediately the first time, but then
+// always returns 1/30th of a second (or immediately if called later) from
+// the last time it was called
+static void loopTimer(void)
+{
+    static timespec lastCall;
+    static int initialized = 0;
+
+    if (!initialized)
+    {
+        clock_gettime(CLOCK_MONOTONIC, &lastCall);
+        initialized = 1;
+        return;
+    }
+
+    do
+    {
+        timespec curTime;
+        clock_gettime(CLOCK_MONOTONIC, &curTime);
+
+        timespec diff = timespec_diff(lastCall, curTime);
+
+        // This is really 30 times per second
+        if (diff.tv_sec || diff.tv_nsec > 33333333)
+        {
+            lastCall = curTime;
+            return;
+        }
+
+        // We need to sleep some period time microseconds
+        unsigned int sleepTime = 33333 - (diff.tv_nsec / 1000);
+        usleep(sleepTime);
+    } while(1);
+    return;
+}
+
+static int runPages(void)
+{
+    // Raise the curtain
+    if (gCurtain != NULL)
+    {
+        gr_surface surface;
+
+        PageManager::Render();
+        gr_get_surface(&surface);
+        curtainRaise(surface);
+        gr_free_surface(surface);
+    }
+
+    gGuiRunning = 1;
+
+    DataManager::SetValue("tw_loaded", 1);
+
+    for (;;)
+    {
+        loopTimer();
+
+        if (!gForceRender)
+        {
+            int ret;
+
+            ret = PageManager::Update();
+            if (ret > 1)
+                PageManager::Render();
+
+            if (ret > 0)
+                flip();
+        }
+        else
+        {
+            gForceRender = 0;
+            PageManager::Render();
+            flip();
+        }
+    }
+
+    gGuiRunning = 0;
+    return 0;
+}
+
+int gui_forceRender(void)
+{
+    gForceRender = 1;
+    return 0;
+}
+
+int gui_changePage(std::string newPage)
+{
+    LOGI("Set page: '%s'\n", newPage.c_str());
+    PageManager::ChangePage(newPage);
+    gForceRender = 1;
+    return 0;
+}
+
+int gui_changeOverlay(std::string overlay)
+{
+    PageManager::ChangeOverlay(overlay);
+    gForceRender = 1;
+    return 0;
+}
+
+int gui_changePackage(std::string newPackage)
+{
+    PageManager::SelectPackage(newPackage);
+    gForceRender = 1;
+    return 0;
+}
+
+std::string gui_parse_text(string inText)
+{
+	// Copied from std::string GUIText::parseText(void)
+	// This function parses text for DataManager values encompassed by %value% in the XML
+	static int counter = 0;
+    std::string str = inText;
+    size_t pos = 0;
+    size_t next = 0, end = 0;
+
+    while (1)
+    {
+        next = str.find('%', pos);
+        if (next == std::string::npos)      return str;
+        end = str.find('%', next + 1);
+        if (end == std::string::npos)       return str;
+
+        // We have a block of data
+        std::string var = str.substr(next + 1, (end - next) - 1);
+        str.erase(next, (end - next) + 1);
+
+        if (next + 1 == end)
+        {
+            str.insert(next, 1, '%');
+        }
+        else
+        {
+            std::string value;
+            if (DataManager::GetValue(var, value) == 0)
+                str.insert(next, value);
+        }
+
+        pos = next + 1;
+    }
+}
+
+extern "C" int gui_init()
+{
+    int fd;
+
+	gr_init();
+
+    // We need to write out the curtain blob
+    if (sizeof(gCurtainBlob) > 32)
+    {
+		fd = open("/tmp/extract.jpg", O_CREAT | O_WRONLY | O_TRUNC);
+        if (fd < 0)
+            return 0;
+    
+		write(fd, gCurtainBlob, sizeof(gCurtainBlob));
+        close(fd);
+    
+		if (res_create_surface("/tmp/extract.jpg", &gCurtain))
+        {
+            return -1;
+        }
+    }
+    else
+    {
+        gNoAnimation = 1;
+        if (res_create_surface("bootup", &gCurtain))
+            return 0;
+    }
+    unlink("/tmp/extract.png");
+
+	curtainSet();
+
+	ev_init();
+    return 0;
+}
+
+extern "C" int gui_loadResources()
+{
+    // Make sure the sdcard is mounted before we continue
+//#ifdef RECOVERY_SDCARD_ON_DATA
+    /*mkdir("/mnt/data-sdc", 0777);
+    mount(dat.blk, "/mnt/data-sdc", dat.fst, 0, NULL);
+    if (symlink("/mnt/data-sdc/media", "/sdcard"))
+    {
+        LOGE("Unable to symlink (errno %d)\n", errno);
+    }*/
+//#else
+//#endif
+
+//    unlink("/sdcard/video.last");
+//    rename("/sdcard/video.bin", "/sdcard/video.last");
+//    gRecorder = open("/sdcard/video.bin", O_CREAT | O_WRONLY);
+
+	int check = 0;
+	DataManager::GetValue(TW_HAS_CRYPTO, check);
+	if (check) {
+		if (ensure_path_mounted("/data") < 0) {
+			// Data failed to mount - probably encrypted
+			DataManager::SetValue(TW_IS_ENCRYPTED, 1);
+			DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
+			DataManager::SetValue("tw_crypto_display", "");
+			if (PageManager::LoadPackage("TWRP", "/res/ui.xml", "decrypt"))
+			{
+				LOGE("Failed to load base packages.\n");
+				goto error;
+			} else
+				check = 1;
+		} else
+			check = 0; // Data mounted, not ecrypted, keep going like normal
+	}
+	if (check == 0 && PageManager::LoadPackage("TWRP", "/script/ui.xml", "main")) {
+		std::string theme_path;
+
+		theme_path = DataManager::GetSettingsStoragePath();
+		if (ensure_path_mounted(theme_path.c_str()) < 0) {
+			int retry_count = 5;
+			while (retry_count > 0 && (ensure_path_mounted(theme_path.c_str()) < 0)) {
+				usleep(500000);
+				ensure_path_mounted(theme_path.c_str());
+				retry_count--;
+			}
+			if (ensure_path_mounted(theme_path.c_str()) < 0) {
+				LOGE("Unable to mount %s during GUI startup.\n", theme_path.c_str());
+				check = 1;
+			}
+		}
+
+		theme_path += "/TWRP/theme/ui.zip";
+		if (check || PageManager::LoadPackage("TWRP", theme_path, "main"))
+		{
+			if (PageManager::LoadPackage("TWRP", "/res/ui.xml", "main"))
+			{
+				LOGE("Failed to load base packages.\n");
+				goto error;
+			}
+		}
+	}
+
+    // Set the default package
+    PageManager::SelectPackage("TWRP");
+
+    gGuiInitialized = 1;
+    return 0;
+
+error:
+    LOGE("An internal error has occurred.\n");
+    gGuiInitialized = 0;
+    return -1;
+}
+
+extern "C" int gui_start()
+{
+    if (!gGuiInitialized)   return -1;
+
+    gGuiConsoleTerminate = 1;
+    while (gGuiConsoleRunning)  loopTimer();
+
+    // Set the default package
+    PageManager::SelectPackage("TWRP");
+
+    // Start by spinning off an input handler.
+    pthread_t t;
+    pthread_create(&t, NULL, input_thread, NULL);
+
+    return runPages();
+}
+
+static void *console_thread(void *cookie)
+{
+    PageManager::SwitchToConsole();
+
+    while (!gGuiConsoleTerminate)
+    {
+        loopTimer();
+
+        if (!gForceRender)
+        {
+            int ret;
+
+            ret = PageManager::Update();
+            if (ret > 1)
+                PageManager::Render();
+
+            if (ret > 0)
+                flip();
+
+            if (ret < 0)
+                LOGE("An update request has failed.\n");
+        }
+        else
+        {
+            gForceRender = 0;
+            PageManager::Render();
+            flip();
+        }
+    }
+    gGuiConsoleRunning = 0;
+    return NULL;
+}
+
+extern "C" int gui_console_only()
+{
+    if (!gGuiInitialized)   return -1;
+
+    gGuiConsoleTerminate = 0;
+    gGuiConsoleRunning = 1;
+
+    // Start by spinning off an input handler.
+    pthread_t t;
+    pthread_create(&t, NULL, console_thread, NULL);
+
+    return 0;
+}