Merge changes Ie5fdacb1,If9adb952,Idb10efa4,Ifbcf97a0,I8dbfde56

* changes:
  Refactor all the unit test cases, as per new example classes.
  Add combo box for supported layout types in the framebufferizer java application.
  Implementation of hit detection for teeui based layout.
  Implementation of touch based layout for teeui based confirmationui.
  Restructure teeui methods into device class.

27 files changed, 1220 insertions, 449 deletions

diff --git a/libteeui/example/Android.bp b/libteeui/example/Android.bp
index b2e8a26..2949bf1 100644
--- a/libteeui/example/Android.bp
+++ b/libteeui/example/Android.bp
@@ -2,8 +2,11 @@ cc_library_static {
     name: "libteeui_example_layout",
     defaults: ["keystore_defaults"],
     srcs: [
+        "examples.cpp",
+        "example_utils.cpp",
         "fonts.S",
-        "teeui.cpp",
+        "phys_button_example.cpp",
+        "touch_button_example.cpp",
     ],
     static_libs: [
         "libft2.nodep",
diff --git a/libteeui/example/example_utils.cpp b/libteeui/example/example_utils.cpp
new file mode 100644
index 0000000..b707356
--- /dev/null
+++ b/libteeui/example/example_utils.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020, 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 <stddef.h>
+
+#include <teeui/label.h>
+#include <teeui/localization/ConfirmationUITranslations.h>
+
+#include "example_utils.h"
+
+namespace teeui {
+namespace example {
+
+uint32_t alfaCombineChannel(uint32_t shift, double alfa, uint32_t a, uint32_t b) {
+    a >>= shift;
+    a &= 0xff;
+    b >>= shift;
+    b &= 0xff;
+    double acc = alfa * a + (1 - alfa) * b;
+    if (acc <= 0) return 0;
+    uint32_t result = acc;
+    if (result > 255) return 255 << shift;
+    return result << shift;
+}
+
+Error FrameBuffer::drawPixel(uint32_t x, uint32_t y, uint32_t color) const {
+    size_t pos = (top_ + y) * lineStride_ + x + left_;
+    if (pos >= size_in_elements_) {
+        return Error::OutOfBoundsDrawing;
+    }
+    double alfa = (color & 0xff000000) >> 24;
+    alfa /= 255.0;
+    auto acc = buffer_[pos];
+    buffer_[pos] = alfaCombineChannel(0, alfa, color, acc) |
+                   alfaCombineChannel(8, alfa, color, acc) |
+                   alfaCombineChannel(16, alfa, color, acc);
+    return Error::OK;
+}
+
+void translate(LabelImpl* label) {
+    uint64_t textId = label->textId();
+    const char* translation =
+        localization::lookup(static_cast<localization::TranslationId>(textId));
+    label->setText({&translation[0], &translation[strlen(translation)]});
+}
+
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/example_utils.h b/libteeui/example/example_utils.h
new file mode 100644
index 0000000..568542d
--- /dev/null
+++ b/libteeui/example/example_utils.h
@@ -0,0 +1,74 @@
+/*
+ *
+ * Copyright 2019, 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.
+ */
+
+#pragma once
+
+#include <stddef.h>
+
+#include <teeui/label.h>
+
+namespace teeui {
+namespace example {
+
+/*
+ * AOSP color scheme constants.
+ */
+constexpr static const Color kShieldColor = Color(0xff778500);
+constexpr static const Color kShieldColorInv = Color(0xffc4cb80);
+constexpr static const Color kTextColor = Color(0xff212121);
+constexpr static const Color kTextColorInv = Color(0xffdedede);
+constexpr static const Color kBackGroundColor = Color(0xffffffff);
+constexpr static const Color kBackGroundColorInv = Color(0xff212121);
+
+uint32_t alfaCombineChannel(uint32_t shift, double alfa, uint32_t a, uint32_t b);
+
+template <typename T> uint32_t renderPixel(uint32_t x, uint32_t y, const T& e) {
+    return e.bounds_.drawPoint(Point<pxs>(x, y));
+}
+
+struct FrameBuffer {
+    uint32_t left_;
+    uint32_t top_;
+    uint32_t width_;
+    uint32_t height_;
+    uint32_t* buffer_;
+    size_t size_in_elements_;
+    uint32_t lineStride_;
+
+    Error drawPixel(uint32_t x, uint32_t y, uint32_t color) const;
+};
+
+template <typename... Elements>
+Error drawElements(std::tuple<Elements...>& layout, const PixelDrawer& drawPixel) {
+    // Error::operator|| is overloaded, so we don't get short circuit evaluation.
+    // But we get the first error that occurs. We will still try and draw the remaining
+    // elements in the order they appear in the layout tuple.
+    return (std::get<Elements>(layout).draw(drawPixel) || ...);
+}
+
+template <typename... Elements>
+Error handleAllEvent(std::tuple<Elements...>& layout, const Event& event) {
+    return (std::get<Elements>(layout).hit(event) || ...);
+}
+
+void translate(LabelImpl* label);
+
+template <typename T, typename Layout> void translateLabel(Layout* layout) {
+    translate(&std::get<T>(*layout));
+}
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/examples.cpp b/libteeui/example/examples.cpp
new file mode 100644
index 0000000..7528414
--- /dev/null
+++ b/libteeui/example/examples.cpp
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2020, 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 "phys_button_example.h"
+#include "touch_button_example.h"
+
+namespace teeui {
+namespace example {
+
+std::unique_ptr<ITeeuiExample> createExample(Examples example) {
+    switch (example) {
+    case Examples::PhysButton:
+        return phys_button::createTeeuiExample();
+    case Examples::TouchButton:
+        return touch_button::createTeeuiExample();
+    }
+}
+
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/layout/common_layout_params.h b/libteeui/example/layout/common_layout_params.h
new file mode 100644
index 0000000..9ba2537
--- /dev/null
+++ b/libteeui/example/layout/common_layout_params.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <teeui/utils.h>
+
+#include "fonts.h"
+
+namespace teeui {
+namespace example {
+
+DECLARE_PARAMETER(RightEdgeOfScreen);
+DECLARE_PARAMETER(BottomOfScreen);
+DECLARE_PARAMETER(DefaultFontSize);  // 14_dp regular and 18_dp magnified
+DECLARE_PARAMETER(BodyFontSize);     // 16_dp regular and 20_dp magnified
+DECLARE_TYPED_PARAMETER(ShieldColor, ::teeui::Color);
+DECLARE_TYPED_PARAMETER(ColorText, ::teeui::Color);
+DECLARE_TYPED_PARAMETER(ColorBG, ::teeui::Color);
+
+CONSTANT(BorderWidth, 24_dp);
+
+DECLARE_FONT_BUFFER(RobotoMedium, RobotoMedium, RobotoMedium_length);
+DECLARE_FONT_BUFFER(RobotoRegular, RobotoRegular, RobotoRegular_length);
+DECLARE_FONT_BUFFER(Shield, Shield, Shield_length);
+
+CONSTANT(DefaultFont, FONT(RobotoRegular));
+
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/layout.h b/libteeui/example/layout/phys_button_layout.h
index 7318a0c..a3f1fe7 100644
--- a/libteeui/example/layout.h
+++ b/libteeui/example/layout/phys_button_layout.h
@@ -19,31 +19,24 @@
 #include <teeui/button.h>
 #include <teeui/label.h>
 #include <teeui/localization/ConfirmationUITranslations.h>
-#include <teeui/utils.h>
 
-#include "fonts.h"
+#include "common_layout_params.h"
 
 using teeui::localization::TranslationId;
 
 namespace teeui {
+namespace example {
+namespace phys_button {
 
-DECLARE_PARAMETER(RightEdgeOfScreen);
-DECLARE_PARAMETER(BottomOfScreen);
 DECLARE_PARAMETER(PowerButtonTop);
 DECLARE_PARAMETER(PowerButtonBottom);
 DECLARE_PARAMETER(VolUpButtonTop);
 DECLARE_PARAMETER(VolUpButtonBottom);
-DECLARE_PARAMETER(DefaultFontSize);  // 14_dp regular and 18_dp magnified
-DECLARE_PARAMETER(BodyFontSize);     // 16_dp regular and 20_dp magnified
-DECLARE_TYPED_PARAMETER(ShieldColor, ::teeui::Color);
-DECLARE_TYPED_PARAMETER(ColorText, ::teeui::Color);
-DECLARE_TYPED_PARAMETER(ColorBG, ::teeui::Color);
 
 NEW_PARAMETER_SET(ConUIParameters, RightEdgeOfScreen, BottomOfScreen, PowerButtonTop,
                   PowerButtonBottom, VolUpButtonTop, VolUpButtonBottom, DefaultFontSize,
                   BodyFontSize, ShieldColor, ColorText, ColorBG);
 
-CONSTANT(BorderWidth, 24_dp);
 CONSTANT(PowerButtonCenter, (PowerButtonTop() + PowerButtonBottom()) / 2_px);
 CONSTANT(VolUpButtonCenter, (VolUpButtonTop() + VolUpButtonBottom()) / 2.0_px);
 CONSTANT(GrayZone, 12_dp);
@@ -59,12 +52,6 @@ CONSTANT(ARROW_SHAPE,
                         CONVEX_OBJECT(Vec2d{6.0_dp - SQRT8, 6.0_dp}, Vec2d{6.0_dp, 6.0_dp},
                                       Vec2d{0.0_dp, 12.0_dp}, Vec2d{-SQRT2, 12.0_dp - SQRT2})));
 
-DECLARE_FONT_BUFFER(RobotoMedium, RobotoMedium, RobotoMedium_length);
-DECLARE_FONT_BUFFER(RobotoRegular, RobotoRegular, RobotoRegular_length);
-DECLARE_FONT_BUFFER(Shield, Shield, Shield_length);
-
-CONSTANT(DefaultFont, FONT(RobotoRegular));
-
 BEGIN_ELEMENT(LabelOK, teeui::Label)
 FontSize(DefaultFontSize());
 LineHeight(20_dp);
@@ -166,4 +153,6 @@ END_ELEMENT();
 NEW_LAYOUT(ConfUILayout, LabelOK, IconPower, LabelCancel, IconVolUp, IconShield, LabelTitle,
            LabelHint, LabelBody);
 
-}  // namespace teeui
+}  // namespace phys_button
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/layout/touch_button_layout.h b/libteeui/example/layout/touch_button_layout.h
new file mode 100644
index 0000000..a7eab50
--- /dev/null
+++ b/libteeui/example/layout/touch_button_layout.h
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2019, 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.
+ */
+
+#pragma once
+
+#include <teeui/button.h>
+#include <teeui/label.h>
+#include <teeui/localization/ConfirmationUITranslations.h>
+
+#include "common_layout_params.h"
+
+using teeui::localization::TranslationId;
+
+namespace teeui {
+namespace example {
+namespace touch_button {
+
+DECLARE_TYPED_PARAMETER(ColorButton, ::teeui::Color);
+
+NEW_PARAMETER_SET(ConfUIParameters, RightEdgeOfScreen, BottomOfScreen, DefaultFontSize,
+                  BodyFontSize, ShieldColor, ColorText, ColorBG, ColorButton);
+
+CONSTANT(IconShieldDistanceFromTop, 100_dp);
+CONSTANT(LabelBorderZone, 4_dp);
+CONSTANT(RightLabelEdge, RightEdgeOfScreen() - BorderWidth);
+CONSTANT(LabelWidth, RightLabelEdge - BorderWidth);
+CONSTANT(ButtonHeight, 72_dp);
+CONSTANT(ButtonPositionX, 0);
+CONSTANT(ButtonPositionY, BottomOfScreen() - ButtonHeight);
+CONSTANT(ButtonWidth, 130_dp);
+CONSTANT(ButtonLabelDistance, 12_dp);
+
+BEGIN_ELEMENT(IconShield, teeui::Label)
+FontSize(24_dp);
+LineHeight(24_dp);
+NumberOfLines(1);
+Dimension(LabelWidth, HeightFromLines);
+Position(BorderWidth, IconShieldDistanceFromTop);
+DefaultText("A");  // ShieldTTF has just one glyph at the code point for capital A
+TextColor(ShieldColor());
+HorizontalTextAlignment(Alignment::CENTER);
+Font(FONT(Shield));
+END_ELEMENT();
+
+BEGIN_ELEMENT(LabelTitle, teeui::Label)
+FontSize(20_dp);
+LineHeight(20_dp);
+NumberOfLines(1);
+Dimension(LabelWidth, HeightFromLines);
+Position(BorderWidth, BOTTOM_EDGE_OF(IconShield) + 16_dp);
+DefaultText("Android Protected Confirmation");
+Font(FONT(RobotoMedium));
+VerticallyCentered;
+TextColor(ColorText());
+TextID(TEXT_ID(TranslationId::TITLE));
+END_ELEMENT();
+
+BEGIN_ELEMENT(IconOk, teeui::Button, ConvexObjectCount(1))
+Dimension(ButtonWidth, ButtonHeight - BorderWidth);
+Position(RightEdgeOfScreen() - ButtonWidth - BorderWidth, ButtonPositionY + ButtonLabelDistance);
+CornerRadius(4_dp);
+ButtonColor(ColorButton());
+RoundTopLeft;
+RoundBottomLeft;
+RoundTopRight;
+RoundBottomRight;
+END_ELEMENT();
+
+BEGIN_ELEMENT(LabelOK, teeui::Label)
+FontSize(BodyFontSize());
+LineHeight(BodyFontSize() * 1.4_px);
+NumberOfLines(1);
+Dimension(ButtonWidth - (LabelBorderZone * 2_dp),
+          ButtonHeight - BorderWidth - (LabelBorderZone * 2_dp));
+Position(RightEdgeOfScreen() - ButtonWidth - BorderWidth + LabelBorderZone,
+         ButtonPositionY + ButtonLabelDistance + LabelBorderZone);
+DefaultText("Confirm");
+Font(FONT(RobotoMedium));
+HorizontalTextAlignment(Alignment::CENTER);
+VerticalTextAlignment(Alignment::CENTER);
+TextColor(ColorBG());
+TextID(TEXT_ID(TranslationId::CONFIRM));
+END_ELEMENT();
+
+BEGIN_ELEMENT(LabelCancel, teeui::Label)
+FontSize(BodyFontSize());
+LineHeight(BodyFontSize() * 1.4_px);
+NumberOfLines(1);
+Dimension(ButtonWidth - (LabelBorderZone * 2_dp),
+          ButtonHeight - BorderWidth - (LabelBorderZone * 2_dp));
+Position(BorderWidth + LabelBorderZone, ButtonPositionY + ButtonLabelDistance + LabelBorderZone);
+DefaultText("Cancel");
+HorizontalTextAlignment(Alignment::LEFT);
+Font(FONT(RobotoMedium));
+VerticallyCentered;
+TextColor(ColorButton());
+TextID(TEXT_ID(TranslationId::CANCEL));
+END_ELEMENT();
+
+BEGIN_ELEMENT(LabelHint, teeui::Label)
+FontSize(DefaultFontSize());
+LineHeight(DefaultFontSize() * 1.5_px);
+NumberOfLines(4);
+Dimension(LabelWidth, HeightFromLines);
+Position(BorderWidth, ButtonPositionY - dim_h - 48_dp);
+DefaultText("This confirmation provides an extra layer of security for the action you're "
+            "about to take.");
+VerticalTextAlignment(Alignment::BOTTOM);
+TextColor(ColorText());
+Font(DefaultFont);
+TextID(TEXT_ID(TranslationId::DESCRIPTION));
+END_ELEMENT();
+
+BEGIN_ELEMENT(LabelBody, teeui::Label)
+FontSize(BodyFontSize());
+LineHeight(BodyFontSize() * 1.4_px);
+NumberOfLines(20);
+Position(BorderWidth, BOTTOM_EDGE_OF(LabelTitle) + 16_dp);
+Dimension(LabelWidth, LabelHint::pos_y - pos_y - 24_dp);
+DefaultText("12345678901234567890123456789012345678901234567890123456789012345678901234567890123456"
+            "78901234567890");
+TextColor(ColorText());
+Font(FONT(RobotoRegular));
+END_ELEMENT();
+
+NEW_LAYOUT(ConfUILayout, IconShield, LabelTitle, LabelHint, LabelBody, IconOk, LabelOK,
+           LabelCancel);
+}  // namespace touch_button
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/phys_button_example.cpp b/libteeui/example/phys_button_example.cpp
new file mode 100644
index 0000000..e490925
--- /dev/null
+++ b/libteeui/example/phys_button_example.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2020, 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 "phys_button_example.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "example_utils.h"
+#include "layout/phys_button_layout.h"
+
+#include <memory>
+
+namespace teeui {
+namespace example {
+namespace phys_button {
+
+template <typename Layout> static void translateLabels(Layout* layout) {
+    translateLabel<LabelOK>(layout);
+    translateLabel<LabelCancel>(layout);
+    translateLabel<LabelTitle>(layout);
+    translateLabel<LabelHint>(layout);
+}
+
+class GUIStatePhysButtons : public ITeeuiExample {
+  public:
+    bool inverted_;
+    std::string confirmationMessage_;
+    layout_t<ConfUILayout> layoutInstance_ = {};
+
+    GUIStatePhysButtons() : inverted_(false), layoutInstance_{} {}
+
+    void selectLanguage(const char* language_id) override {
+        teeui::localization::selectLangId(language_id);
+        translateLabels(&layoutInstance_);
+    }
+
+    void setConfirmationMessage(std::string confirmationMessage) override {
+        confirmationMessage_ = std::move(confirmationMessage);
+        std::get<LabelBody>(layoutInstance_)
+            .setText({&*confirmationMessage_.begin(), &*confirmationMessage_.end()});
+    }
+
+    uint32_t setDeviceInfo(DeviceInfo device_info, bool magnified, bool inverted = false) override;
+    EventResult onEvent(uint32_t, uint32_t, uint32_t) override { return EventResult::NONE; }
+
+    uint32_t renderUIIntoBuffer(uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t lineStride,
+                                uint32_t* buffer,
+                                size_t buffer_size_in_elements_not_bytes) override;
+};
+
+std::unique_ptr<ITeeuiExample> createTeeuiExample() {
+    return std::make_unique<GUIStatePhysButtons>();
+}
+
+static context<ConUIParameters> setLayoutParams(DeviceInfo& deviceInfo, bool magnified,
+                                                bool inverted) {
+    context<ConUIParameters> ctx(deviceInfo.mm2px_, deviceInfo.dp2px_);
+    ctx.setParam<RightEdgeOfScreen>(pxs(deviceInfo.width_));
+    ctx.setParam<BottomOfScreen>(pxs(deviceInfo.height_));
+    ctx.setParam<PowerButtonTop>(mms(deviceInfo.powerButtonTopMm_));
+    ctx.setParam<PowerButtonBottom>(mms(deviceInfo.powerButtonBottomMm_));
+    ctx.setParam<VolUpButtonTop>(mms(deviceInfo.volUpButtonTopMm_));
+    ctx.setParam<VolUpButtonBottom>(mms(deviceInfo.volUpButtonBottomMm_));
+    if (magnified) {
+        ctx.setParam<DefaultFontSize>(18_dp);
+        ctx.setParam<BodyFontSize>(20_dp);
+    } else {
+        ctx.setParam<DefaultFontSize>(14_dp);
+        ctx.setParam<BodyFontSize>(16_dp);
+    }
+    if (inverted) {
+        ctx.setParam<ShieldColor>(kShieldColorInv);
+        ctx.setParam<ColorText>(kTextColorInv);
+        ctx.setParam<ColorBG>(kBackGroundColorInv);
+    } else {
+        ctx.setParam<ShieldColor>(kShieldColor);
+        ctx.setParam<ColorText>(kTextColor);
+        ctx.setParam<ColorBG>(kBackGroundColor);
+    }
+    return ctx;
+}
+
+uint32_t GUIStatePhysButtons::setDeviceInfo(DeviceInfo device_info, bool magnified, bool inverted) {
+    layoutInstance_ =
+        instantiateLayout(ConfUILayout(), setLayoutParams(device_info, magnified, inverted));
+    inverted_ = inverted;
+
+    return 0;
+}
+
+uint32_t GUIStatePhysButtons::renderUIIntoBuffer(uint32_t x, uint32_t y, uint32_t w, uint32_t h,
+                                                 uint32_t lineStride, uint32_t* buffer,
+                                                 size_t buffer_size_in_elements_not_bytes) {
+    uint32_t afterLastPixelIndex = 0;
+    if (__builtin_add_overflow(y, h, &afterLastPixelIndex) ||
+        __builtin_add_overflow(afterLastPixelIndex, -1, &afterLastPixelIndex) ||
+        __builtin_mul_overflow(afterLastPixelIndex, lineStride, &afterLastPixelIndex) ||
+        __builtin_add_overflow(afterLastPixelIndex, x, &afterLastPixelIndex) ||
+        __builtin_add_overflow(afterLastPixelIndex, w, &afterLastPixelIndex) ||
+        afterLastPixelIndex > buffer_size_in_elements_not_bytes) {
+        return uint32_t(Error::OutOfBoundsDrawing);
+    }
+
+    uint32_t* begin = buffer + (y * lineStride + x);
+
+    Color bgColor = inverted_ ? kBackGroundColorInv : kBackGroundColor;
+
+    for (uint32_t yi = 0; yi < h; ++yi) {
+        for (uint32_t xi = 0; xi < w; ++xi) {
+            begin[xi] = bgColor;
+        }
+        begin += lineStride;
+    }
+    FrameBuffer fb;
+    fb.left_ = x;
+    fb.top_ = y;
+    fb.width_ = w;
+    fb.height_ = h;
+    fb.buffer_ = buffer;
+    fb.size_in_elements_ = buffer_size_in_elements_not_bytes;
+    fb.lineStride_ = lineStride;
+
+    auto pixelDrawer = makePixelDrawer(
+        [&fb](uint32_t x, uint32_t y, Color color) -> Error { return fb.drawPixel(x, y, color); });
+
+    if (auto error = drawElements(layoutInstance_, pixelDrawer)) {
+        return uint32_t(error.code());
+    }
+
+    return 0;  // OK
+}
+
+}  // namespace phys_button
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/phys_button_example.h b/libteeui/example/phys_button_example.h
new file mode 100644
index 0000000..268f2d4
--- /dev/null
+++ b/libteeui/example/phys_button_example.h
@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright 2019, 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.
+ */
+
+#pragma once
+
+#include <memory>
+#include <teeui/example/example.h>
+
+namespace teeui {
+namespace example {
+namespace phys_button {
+
+std::unique_ptr<ITeeuiExample> createTeeuiExample();
+
+}  // namespace phys_button
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/example/teeui.cpp b/libteeui/example/teeui.cpp
deleted file mode 100644
index b415283..0000000
--- a/libteeui/example/teeui.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- *
- * Copyright 2019, 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 "layout.h"
-#include <cassert>
-#include <iostream>
-#include <teeui/example/teeui.h>
-#include <teeui/localization/ConfirmationUITranslations.h>
-#include <typeinfo>
-
-using namespace teeui;
-
-static DeviceInfo sDeviceInfo;
-static bool sMagnified;
-static bool sInverted;
-static std::string sConfirmationMessage;
-
-/*
- * AOSP color scheme constants.
- */
-constexpr static const Color kShieldColor = Color(0xff778500);
-constexpr static const Color kShieldColorInv = Color(0xffc4cb80);
-constexpr static const Color kTextColor = Color(0xff212121);
-constexpr static const Color kTextColorInv = Color(0xffdedede);
-constexpr static const Color kBackGroundColor = Color(0xffffffff);
-constexpr static const Color kBackGroundColorInv = Color(0xff212121);
-
-void setConfirmationMessage(const char* confirmationMessage) {
-    sConfirmationMessage = confirmationMessage;
-}
-
-uint32_t alfaCombineChannel(uint32_t shift, double alfa, uint32_t a, uint32_t b) {
-    a >>= shift;
-    a &= 0xff;
-    b >>= shift;
-    b &= 0xff;
-    double acc = alfa * a + (1 - alfa) * b;
-    if (acc <= 0) return 0;
-    uint32_t result = acc;
-    if (result > 255) return 255 << shift;
-    return result << shift;
-}
-
-template <typename T> uint32_t renderPixel(uint32_t x, uint32_t y, const T& e) {
-    return e.bounds_.drawPoint(Point<pxs>(x, y));
-}
-
-struct FrameBuffer {
-    uint32_t left_;
-    uint32_t top_;
-    uint32_t width_;
-    uint32_t height_;
-    uint32_t* buffer_;
-    size_t size_in_elements_;
-    uint32_t lineStride_;
-
-    Error drawPixel(uint32_t x, uint32_t y, uint32_t color) const {
-        size_t pos = (top_ + y) * lineStride_ + x + left_;
-        if (pos >= size_in_elements_) {
-            return Error::OutOfBoundsDrawing;
-        }
-        double alfa = (color & 0xff000000) >> 24;
-        alfa /= 255.0;
-        auto acc = buffer_[pos];
-        buffer_[pos] = alfaCombineChannel(0, alfa, color, acc) |
-                       alfaCombineChannel(8, alfa, color, acc) |
-                       alfaCombineChannel(16, alfa, color, acc);
-        return Error::OK;
-    }
-};
-
-template <typename... Elements>
-Error drawElements(std::tuple<Elements...>& layout, const PixelDrawer& drawPixel) {
-    // Error::operator|| is overloaded, so we don't get short circuit evaluation.
-    // But we get the first error that occurs. We will still try and draw the remaining
-    // elements in the order they appear in the layout tuple.
-    return (std::get<Elements>(layout).draw(drawPixel) || ...);
-}
-
-uint32_t setDeviceInfo(DeviceInfo deviceInfo, bool magnified, bool inverted) {
-    sDeviceInfo = deviceInfo;
-    sMagnified = magnified;
-    sInverted = inverted;
-    return 0;
-}
-
-void selectLanguage(const char* language_id) {
-    teeui::localization::selectLangId(language_id);
-}
-
-void translate(LabelImpl* label) {
-    uint64_t textId = label->textId();
-    const char* translation =
-        teeui::localization::lookup(static_cast<teeui::localization::TranslationId>(textId));
-    label->setText({&translation[0], &translation[strlen(translation)]});
-}
-
-template <typename... Elements> void translateLabels(std::tuple<Elements...>& layout) {
-    translate(&std::get<LabelOK>(layout));
-    translate(&std::get<LabelCancel>(layout));
-    translate(&std::get<LabelTitle>(layout));
-    translate(&std::get<LabelHint>(layout));
-}
-
-uint32_t renderUIIntoBuffer(uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t lineStride,
-                            uint32_t* buffer, size_t buffer_size_in_elements_not_bytes) {
-    uint32_t afterLastPixelIndex = 0;
-    if (__builtin_add_overflow(y, h, &afterLastPixelIndex) ||
-        __builtin_add_overflow(afterLastPixelIndex, -1, &afterLastPixelIndex) ||
-        __builtin_mul_overflow(afterLastPixelIndex, lineStride, &afterLastPixelIndex) ||
-        __builtin_add_overflow(afterLastPixelIndex, x, &afterLastPixelIndex) ||
-        __builtin_add_overflow(afterLastPixelIndex, w, &afterLastPixelIndex) ||
-        afterLastPixelIndex > buffer_size_in_elements_not_bytes) {
-        return uint32_t(Error::OutOfBoundsDrawing);
-    }
-    context<ConUIParameters> ctx(sDeviceInfo.mm2px_, sDeviceInfo.dp2px_);
-    ctx.setParam<RightEdgeOfScreen>(pxs(sDeviceInfo.width_));
-    ctx.setParam<BottomOfScreen>(pxs(sDeviceInfo.height_));
-    ctx.setParam<PowerButtonTop>(mms(sDeviceInfo.powerButtonTopMm_));
-    ctx.setParam<PowerButtonBottom>(mms(sDeviceInfo.powerButtonBottomMm_));
-    ctx.setParam<VolUpButtonTop>(mms(sDeviceInfo.volUpButtonTopMm_));
-    ctx.setParam<VolUpButtonBottom>(mms(sDeviceInfo.volUpButtonBottomMm_));
-    if (sMagnified) {
-        ctx.setParam<DefaultFontSize>(18_dp);
-        ctx.setParam<BodyFontSize>(20_dp);
-    } else {
-        ctx.setParam<DefaultFontSize>(14_dp);
-        ctx.setParam<BodyFontSize>(16_dp);
-    }
-
-    if (sInverted) {
-        ctx.setParam<ShieldColor>(kShieldColorInv);
-        ctx.setParam<ColorText>(kTextColorInv);
-        ctx.setParam<ColorBG>(kBackGroundColorInv);
-    } else {
-        ctx.setParam<ShieldColor>(kShieldColor);
-        ctx.setParam<ColorText>(kTextColor);
-        ctx.setParam<ColorBG>(kBackGroundColor);
-    }
-
-    auto layoutInstance = instantiateLayout(ConfUILayout(), ctx);
-
-    translateLabels(layoutInstance);
-
-    uint32_t* begin = buffer + (y * lineStride + x);
-
-    Color bgColor = sInverted ? kBackGroundColorInv : kBackGroundColor;
-
-    for (uint32_t yi = 0; yi < h; ++yi) {
-        for (uint32_t xi = 0; xi < w; ++xi) {
-            begin[xi] = bgColor;
-        }
-        begin += lineStride;
-    }
-    FrameBuffer fb;
-    fb.left_ = x;
-    fb.top_ = y;
-    fb.width_ = w;
-    fb.height_ = h;
-    fb.buffer_ = buffer;
-    fb.size_in_elements_ = buffer_size_in_elements_not_bytes;
-    fb.lineStride_ = lineStride;
-
-    auto pixelDrawer = makePixelDrawer(
-        [&fb](uint32_t x, uint32_t y, Color color) -> Error { return fb.drawPixel(x, y, color); });
-
-    std::get<LabelBody>(layoutInstance)
-        .setText({&*sConfirmationMessage.begin(), &*sConfirmationMessage.end()});
-
-    if (auto error = drawElements(layoutInstance, pixelDrawer)) {
-        return uint32_t(error.code());
-    }
-
-    return 0;  // OK
-}
diff --git a/libteeui/example/touch_button_example.cpp b/libteeui/example/touch_button_example.cpp
new file mode 100644
index 0000000..c909dbb
--- /dev/null
+++ b/libteeui/example/touch_button_example.cpp
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2020, 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 "touch_button_example.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "example_utils.h"
+#include "layout/touch_button_layout.h"
+
+namespace teeui {
+namespace example {
+namespace touch_button {
+
+template <typename Layout> static void translateLabels(Layout* layout) {
+    translateLabel<LabelOK>(layout);
+    translateLabel<LabelCancel>(layout);
+    translateLabel<LabelTitle>(layout);
+    translateLabel<LabelHint>(layout);
+}
+
+class GUIStateTouch : public ITeeuiExample {
+  private:
+    bool okTapped_ = false;
+    bool cancelTapped_ = false;
+    EventResult eventResult_ = EventResult::NONE;
+
+  public:
+    bool inverted_;
+    std::string confirmationMessage_;
+    layout_t<ConfUILayout> layoutInstance_ = {};
+
+    GUIStateTouch() : okTapped_(false), cancelTapped_(false), inverted_(false), layoutInstance_{} {}
+
+    bool isOkTapped() const { return okTapped_; }
+    bool isCancelTapped() const { return cancelTapped_; }
+
+    Error tapOk(Event e) {
+        if (e.event_ == EventType::KeyUp) {
+            okTapped_ = true;
+            eventResult_ = EventResult::CONFIRM;
+        }
+        return Error::OK;
+    }
+
+    Error tapCancel(Event e) {
+        if (e.event_ == EventType::KeyUp) {
+            cancelTapped_ = true;
+            eventResult_ = EventResult::CANCEL;
+        }
+        return Error::OK;
+    }
+
+    void selectLanguage(const char* language_id) override {
+        teeui::localization::selectLangId(language_id);
+        translateLabels(&layoutInstance_);
+    }
+
+    void setConfirmationMessage(std::string confirmationMessage) override {
+        confirmationMessage_ = std::move(confirmationMessage);
+        std::get<LabelBody>(layoutInstance_)
+            .setText({&*confirmationMessage_.begin(), &*confirmationMessage_.end()});
+    }
+
+    uint32_t setDeviceInfo(DeviceInfo device_info, bool magnified, bool inverted = false) override;
+
+    EventResult onEvent(uint32_t x, uint32_t y, uint32_t) override;
+
+    uint32_t renderUIIntoBuffer(uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t lineStride,
+                                uint32_t* buffer,
+                                size_t buffer_size_in_elements_not_bytes) override;
+};
+
+std::unique_ptr<ITeeuiExample> createTeeuiExample() {
+    return std::make_unique<GUIStateTouch>();
+}
+
+EventResult GUIStateTouch::onEvent(uint32_t x, uint32_t y, uint32_t) {
+    eventResult_ = EventResult::NONE;
+    Event event{x, y, EventType::KeyUp};
+    handleAllEvent(layoutInstance_, event);
+    return eventResult_;
+}
+
+static context<ConfUIParameters> setLayoutParams(DeviceInfo& deviceInfo, bool magnified,
+                                                 bool inverted) {
+    context<ConfUIParameters> ctx(deviceInfo.mm2px_, deviceInfo.dp2px_);
+    ctx.setParam<RightEdgeOfScreen>(pxs(deviceInfo.width_));
+    ctx.setParam<BottomOfScreen>(pxs(deviceInfo.height_));
+    if (magnified) {
+        ctx.setParam<DefaultFontSize>(18_dp);
+        ctx.setParam<BodyFontSize>(20_dp);
+    } else {
+        ctx.setParam<DefaultFontSize>(14_dp);
+        ctx.setParam<BodyFontSize>(16_dp);
+    }
+    if (inverted) {
+        ctx.setParam<ShieldColor>(kShieldColorInv);
+        ctx.setParam<ColorText>(kTextColorInv);
+        ctx.setParam<ColorBG>(kBackGroundColorInv);
+        ctx.setParam<ColorButton>(kShieldColorInv);
+    } else {
+        ctx.setParam<ShieldColor>(kShieldColor);
+        ctx.setParam<ColorText>(kTextColor);
+        ctx.setParam<ColorBG>(kBackGroundColor);
+        ctx.setParam<ColorButton>(kShieldColor);
+    }
+    return ctx;
+}
+
+uint32_t GUIStateTouch::setDeviceInfo(DeviceInfo device_info, bool magnified, bool inverted) {
+    layoutInstance_ =
+        instantiateLayout(ConfUILayout(), setLayoutParams(device_info, magnified, inverted));
+    inverted_ = inverted;
+    std::get<LabelOK>(layoutInstance_)
+        .setCB(makeCallback<Error, Event>(
+            [](Event e, void* p) -> Error { return reinterpret_cast<GUIStateTouch*>(p)->tapOk(e); },
+            this));
+    std::get<LabelCancel>(layoutInstance_)
+        .setCB(makeCallback<Error, Event>(
+            [](Event e, void* p) -> Error {
+                return reinterpret_cast<GUIStateTouch*>(p)->tapCancel(e);
+            },
+            this));
+    return 0;
+}
+
+uint32_t GUIStateTouch::renderUIIntoBuffer(uint32_t x, uint32_t y, uint32_t w, uint32_t h,
+                                           uint32_t lineStride, uint32_t* buffer,
+                                           size_t buffer_size_in_elements_not_bytes) {
+    uint32_t afterLastPixelIndex = 0;
+    if (__builtin_add_overflow(y, h, &afterLastPixelIndex) ||
+        __builtin_add_overflow(afterLastPixelIndex, -1, &afterLastPixelIndex) ||
+        __builtin_mul_overflow(afterLastPixelIndex, lineStride, &afterLastPixelIndex) ||
+        __builtin_add_overflow(afterLastPixelIndex, x, &afterLastPixelIndex) ||
+        __builtin_add_overflow(afterLastPixelIndex, w, &afterLastPixelIndex) ||
+        afterLastPixelIndex > buffer_size_in_elements_not_bytes) {
+        return uint32_t(Error::OutOfBoundsDrawing);
+    }
+
+    uint32_t* begin = buffer + (y * lineStride + x);
+
+    Color bgColor = inverted_ ? kBackGroundColorInv : kBackGroundColor;
+
+    for (uint32_t yi = 0; yi < h; ++yi) {
+        for (uint32_t xi = 0; xi < w; ++xi) {
+            begin[xi] = bgColor;
+        }
+        begin += lineStride;
+    }
+    FrameBuffer fb;
+    fb.left_ = x;
+    fb.top_ = y;
+    fb.width_ = w;
+    fb.height_ = h;
+    fb.buffer_ = buffer;
+    fb.size_in_elements_ = buffer_size_in_elements_not_bytes;
+    fb.lineStride_ = lineStride;
+
+    auto pixelDrawer = makePixelDrawer(
+        [&fb](uint32_t x, uint32_t y, Color color) -> Error { return fb.drawPixel(x, y, color); });
+
+    if (auto error = drawElements(layoutInstance_, pixelDrawer)) {
+        return uint32_t(error.code());
+    }
+
+    return 0;  // OK
+}
+
+}  // namespace touch_button
+}  // namespace example
+}  // namespace teeui
diff --git a/libteeui/example/touch_button_example.h b/libteeui/example/touch_button_example.h
new file mode 100644
index 0000000..90b8554
--- /dev/null
+++ b/libteeui/example/touch_button_example.h
@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright 2019, 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.
+ */
+
+#pragma once
+
+#include <memory>
+#include <teeui/example/example.h>
+
+namespace teeui {
+namespace example {
+namespace touch_button {
+
+std::unique_ptr<ITeeuiExample> createTeeuiExample();
+
+}
+}  // namespace example
+}  // namespace teeui
\ No newline at end of file
diff --git a/libteeui/include/teeui/example/example.h b/libteeui/include/teeui/example/example.h
new file mode 100644
index 0000000..07df995
--- /dev/null
+++ b/libteeui/include/teeui/example/example.h
@@ -0,0 +1,75 @@
+/*
+ *
+ * Copyright 2019, 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 <stddef.h>
+#include <string>
+
+#pragma once
+
+namespace teeui {
+namespace example {
+
+struct DeviceInfo {
+    uint32_t width_;
+    uint32_t height_;
+    double dp2px_;
+    double mm2px_;
+    double powerButtonTopMm_;
+    double powerButtonBottomMm_;
+    double volUpButtonTopMm_;
+    double volUpButtonBottomMm_;
+};
+
+enum class EventResult : uint32_t {
+    NONE,
+    CONFIRM,
+    CANCEL,
+};
+
+class ITeeuiExample {
+  public:
+    virtual void selectLanguage(const char*) = 0;
+    virtual void setConfirmationMessage(std::string) = 0;
+    virtual uint32_t setDeviceInfo(DeviceInfo, bool, bool) = 0;
+    virtual uint32_t renderUIIntoBuffer(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t*,
+                                        size_t) = 0;
+    virtual EventResult onEvent(uint32_t x, uint32_t y, uint32_t) = 0;
+
+    virtual ~ITeeuiExample() {}
+};
+
+enum class Examples : uint32_t {
+    PhysButton,
+    TouchButton,
+};
+
+static constexpr const int8_t kFrameBufferError = -1;
+static constexpr const int8_t kLayoutExampleError = -2;
+static constexpr const char* kPhysButtonLayout = "Physical button";
+static constexpr const char* kTouchButtonLayout = "Touch button";
+
+static constexpr const char* kAvailableLayouts[] = {
+    kPhysButtonLayout,
+    kTouchButtonLayout,
+};
+
+#define NUM_LAYOUTS ((sizeof(kAvailableLayouts) / sizeof(kAvailableLayouts[0])))
+
+std::unique_ptr<ITeeuiExample> createExample(Examples example);
+
+}  // namespace example
+}  // namespace teeui
diff --git a/libteeui/include/teeui/example/teeui.h b/libteeui/include/teeui/example/teeui.h
deleted file mode 100644
index 3ee37f4..0000000
--- a/libteeui/include/teeui/example/teeui.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- *
- * Copyright 2019, 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.
- */
-
-#ifndef TEEUI_LIBTEEUI_INCLUDE_TEEUI_H_
-#define TEEUI_LIBTEEUI_INCLUDE_TEEUI_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-struct DeviceInfo {
-    uint32_t width_;
-    uint32_t height_;
-    double dp2px_;
-    double mm2px_;
-    double powerButtonTopMm_;
-    double powerButtonBottomMm_;
-    double volUpButtonTopMm_;
-    double volUpButtonBottomMm_;
-};
-
-uint32_t setDeviceInfo(DeviceInfo device_info, bool magnified, bool inverted = false);
-uint32_t renderUIIntoBuffer(uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t lineStride,
-                            uint32_t* buffer, size_t buffer_size_in_elements_not_bytes);
-
-void selectLanguage(const char* language_id);
-
-void setConfirmationMessage(const char* confirmationMessage);
-
-#endif  // TEEUI_LIBTEEUI_INCLUDE_TEEUI_H_
diff --git a/libteeui/include/teeui/label.h b/libteeui/include/teeui/label.h
index b3b9114..845922a 100644
--- a/libteeui/include/teeui/label.h
+++ b/libteeui/include/teeui/label.h
@@ -83,6 +83,9 @@ class LabelImpl {
     uint64_t textId() const { return textId_; }
 
     Error draw(const PixelDrawer& drawPixel, const Box<pxs>& bounds, LineInfo* lineInfo);
+    void setCB(CallbackEvent cbEvent) { cbEvent_ = std::move(cbEvent); }
+    optional<CallbackEvent> getCB() { return cbEvent_; }
+    Error hit(const Event& event, const Box<pxs>& bounds);
 
   private:
     pxs fontSize_;
@@ -93,6 +96,7 @@ class LabelImpl {
     Color textColor_;
     FontBuffer font_;
     uint64_t textId_;
+    optional<CallbackEvent> cbEvent_;
 };
 
 /**
@@ -124,6 +128,8 @@ template <typename Derived> class Label : public LayoutElement<Derived>, public
         LabelImpl::LineInfo lineInfo = {Derived::label_number_of_lines, lines};
         return LabelImpl::draw(drawPixel, this->bounds_, &lineInfo);
     }
+
+    Error hit(const Event& event) { return LabelImpl::hit(event, this->bounds_); }
 };
 
 }  //  namespace teeui
diff --git a/libteeui/include/teeui/utils.h b/libteeui/include/teeui/utils.h
index 850d1b0..985761a 100644
--- a/libteeui/include/teeui/utils.h
+++ b/libteeui/include/teeui/utils.h
@@ -259,7 +259,6 @@ template <typename Numeric> struct Div {
     }
 };
 
-template <typename Param, typename Numeric = DefaultNumericType> class context;
 template <typename T1, typename T2, typename Numeric, template <typename> class Op> struct BinOp;
 
 template <typename T1, typename T2, typename Numeric> using add = BinOp<T1, T2, Numeric, Add>;
@@ -435,6 +434,8 @@ struct isMetaParam<MetaParam<ParamName, ParamType>> {
     constexpr static const bool value = true;
 };
 
+template <typename Param, typename Numeric = DefaultNumericType> class context;
+
 template <typename... ParamsNames, typename... ParamTypes, typename Numeric>
 class context<MetaList<MetaParam<ParamsNames, ParamTypes>...>, Numeric> {
     Numeric mm2px_;
@@ -858,6 +859,18 @@ template <typename Coord> std::ostream& operator<<(std::ostream& out, const Box<
 }
 #endif
 
+enum class EventType : uint8_t {
+    KeyDown,
+    KeyUp,
+    KeyMoved,
+};
+
+struct Event {
+    uint32_t x_;
+    uint32_t y_;
+    EventType event_;
+};
+
 template <typename Fn> struct Callback;
 
 template <typename Ret, typename... Args> struct Callback<Ret(Args...)> {
@@ -882,6 +895,7 @@ template <typename Fn, typename Ret, typename... Args> struct CallbackHelper {
     }
 };
 
+using CallbackEvent = Callback<Error(Event)>;
 using PixelDrawer = Callback<Error(uint32_t, uint32_t, Color)>;
 
 template <typename Fn>
@@ -900,6 +914,7 @@ template <typename Derived> struct LayoutElement {
                   context = Derived::dim_h} {}
 
     Error draw(const PixelDrawer&) { return Error::OK; }
+    Error hit(const Event&) { return Error::OK; }
 };
 
 template <typename... Elements, typename Context>
diff --git a/libteeui/src/label.cpp b/libteeui/src/label.cpp
index 8267bf2..34d8eb0 100644
--- a/libteeui/src/label.cpp
+++ b/libteeui/src/label.cpp
@@ -136,4 +136,14 @@ Error LabelImpl::draw(const PixelDrawer& drawPixel, const Box<pxs>& bounds, Line
     return Error::OK;
 }
 
+Error LabelImpl::hit(const Event& event, const Box<pxs>& bounds) {
+    using intpxs = Coordinate<px, int64_t>;
+    if (bounds.contains(Point<intpxs>(event.x_, event.y_))) {
+        optional<CallbackEvent> callback = getCB();
+        if (callback) {
+            return callback.value()(event);
+        }
+    }
+    return Error::OK;
+}
 }  // namespace teeui
diff --git a/libteeui_jni/include/com_android_framebufferizer_NativeRenderer.h b/libteeui_jni/include/com_android_framebufferizer_NativeRenderer.h
index 10b10a8..b5bb08d 100644
--- a/libteeui_jni/include/com_android_framebufferizer_NativeRenderer.h
+++ b/libteeui_jni/include/com_android_framebufferizer_NativeRenderer.h
@@ -10,10 +10,10 @@ extern "C" {
 /*
  * Class:     com_android_framebufferizer_NativeRenderer
  * Method:    setDeviceInfo
- * Signature: (Lcom/android/framebufferizer/utils/DeviceInfo;ZZ)I
+ * Signature: (Lcom/android/framebufferizer/utils/DeviceInfo;ZZLjava/lang/String;)I
  */
 JNIEXPORT jint JNICALL Java_com_android_framebufferizer_NativeRenderer_setDeviceInfo(
-    JNIEnv*, jclass, jobject, jboolean, jboolean);
+    JNIEnv*, jclass, jobject, jboolean, jboolean, jstring);
 
 /*
  * Class:     com_android_framebufferizer_NativeRenderer
@@ -41,12 +41,28 @@ Java_com_android_framebufferizer_NativeRenderer_getLanguageIdList(JNIEnv*, jclas
 
 /*
  * Class:     com_android_framebufferizer_NativeRenderer
+ * Method:    getAvailableLayouts
+ * Signature: ()[Ljava/lang/String;
+ */
+JNIEXPORT jobjectArray JNICALL
+Java_com_android_framebufferizer_NativeRenderer_getAvailableLayouts(JNIEnv*, jclass);
+
+/*
+ * Class:     com_android_framebufferizer_NativeRenderer
  * Method:    setConfimationMessage
  * Signature: (Ljava/lang/String;)V
  */
 JNIEXPORT void JNICALL
 Java_com_android_framebufferizer_NativeRenderer_setConfimationMessage(JNIEnv*, jclass, jstring);
 
+/*
+ * Class:     com_android_framebufferizer_NativeRenderer
+ * Method:    onEvent
+ * Signature: (III)I
+ */
+JNIEXPORT jint JNICALL Java_com_android_framebufferizer_NativeRenderer_onEvent(JNIEnv*, jclass,
+                                                                               jint, jint, jint);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/libteeui_jni/libteeui_jni.cpp b/libteeui_jni/libteeui_jni.cpp
index 960140b..1beae12 100644
--- a/libteeui_jni/libteeui_jni.cpp
+++ b/libteeui_jni/libteeui_jni.cpp
@@ -16,7 +16,7 @@
  */
 
 #include <jni.h>
-#include <teeui/example/teeui.h>
+#include <teeui/example/example.h>
 #include <teeui/localization/ConfirmationUITranslations.h>
 
 using teeui::localization::getLanguages;
@@ -124,13 +124,18 @@ using JIntArray = JArray<jintArray>;
 using JByteArray = JArray<jbyteArray>;
 using JString = JArray<jstring>;
 
+static std::unique_ptr<teeui::example::ITeeuiExample> sCurrentExample;
+
 /*
  * Class:     com_android_framebufferizer_NativeRenderer
  * Method:    setDeviceInfo
- * Signature: (Lcom/android/framebufferizer/utils/DeviceInfo;ZZ)I
+ * Signature: (Lcom/android/framebufferizer/utils/DeviceInfo;ZZLjava/lang/String;)I
  */
 extern "C" JNIEXPORT jint JNICALL Java_com_android_framebufferizer_NativeRenderer_setDeviceInfo(
-    JNIEnv* env, jclass, jobject jDeviceInfo, jboolean magnified, jboolean inverted) {
+    JNIEnv* env, jclass, jobject jDeviceInfo, jboolean magnified, jboolean inverted,
+    jstring layout_type) {
+    JString layout(env, layout_type);
+    using namespace teeui::example;
     jclass cDeviceInfo = env->FindClass("Lcom/android/framebufferizer/utils/DeviceInfo;");
     jmethodID method = env->GetMethodID(cDeviceInfo, "getWidthPx", "()I");
     DeviceInfo device_info;
@@ -149,7 +154,10 @@ extern "C" JNIEXPORT jint JNICALL Java_com_android_framebufferizer_NativeRendere
     device_info.volUpButtonTopMm_ = env->CallDoubleMethod(jDeviceInfo, method);
     method = env->GetMethodID(cDeviceInfo, "getVolUpButtonBottomMm", "()D");
     device_info.volUpButtonBottomMm_ = env->CallDoubleMethod(jDeviceInfo, method);
-    return setDeviceInfo(device_info, magnified, inverted);
+    sCurrentExample =
+        createExample((strcmp(layout.begin(), kTouchButtonLayout) == 0) ? Examples::TouchButton
+                                                                        : Examples::PhysButton);
+    return sCurrentExample->setDeviceInfo(device_info, magnified, inverted);
 }
 
 /*
@@ -161,10 +169,14 @@ extern "C" JNIEXPORT jint JNICALL Java_com_android_framebufferizer_NativeRendere
     JNIEnv* env, jclass, jint x, jint y, jint width, jint height, jint lineStride,
     jintArray jbuffer) {
     JIntArray buffer(env, jbuffer);
-    if (!buffer) return 1;
-    return renderUIIntoBuffer((uint32_t)x, (uint32_t)y, (uint32_t)width, (uint32_t)height,
-                              (uint32_t)lineStride, (uint32_t*)buffer.begin(), buffer.size());
+    using namespace teeui::example;
+    if (!buffer) return kFrameBufferError;
+    if (!sCurrentExample) return kLayoutExampleError;
+    return sCurrentExample->renderUIIntoBuffer((uint32_t)x, (uint32_t)y, (uint32_t)width,
+                                               (uint32_t)height, (uint32_t)lineStride,
+                                               (uint32_t*)buffer.begin(), buffer.size());
 }
+
 /*
  * Class:     com_android_confirmationui_Translation_selectLangID
  * Method:    selectLangID
@@ -172,10 +184,8 @@ extern "C" JNIEXPORT jint JNICALL Java_com_android_framebufferizer_NativeRendere
  */
 extern "C" JNIEXPORT void JNICALL
 Java_com_android_framebufferizer_NativeRenderer_setLanguage(JNIEnv* env, jclass, jstring jlang_id) {
-    jboolean isCopy = false;
-    const char* lang_id = (env)->GetStringUTFChars(jlang_id, &isCopy);
-    selectLanguage(lang_id);
-    (env)->ReleaseStringUTFChars(jlang_id, lang_id);
+    JString lang_id(env, jlang_id);
+    if (sCurrentExample) sCurrentExample->selectLanguage(lang_id.begin());
 }
 /*
  * Class:     com_android_confirmationui_Translation_selectLangID
@@ -197,6 +207,28 @@ Java_com_android_framebufferizer_NativeRenderer_getLanguageIdList(JNIEnv* env, j
 
     return language_ids;
 }
+
+/*
+ * Class:     com_android_framebufferizer_NativeRenderer
+ * Method:    getAvailableLayouts
+ * Signature: ()[Ljava/lang/String;
+ */
+extern "C" JNIEXPORT jobjectArray JNICALL
+Java_com_android_framebufferizer_NativeRenderer_getAvailableLayouts(JNIEnv* env, jclass) {
+    using namespace teeui::example;
+    jobjectArray available_layouts;
+    const char* const* native_data = kAvailableLayouts;
+    size_t list_size = NUM_LAYOUTS;
+
+    available_layouts = (jobjectArray)env->NewObjectArray(
+        list_size, env->FindClass("java/lang/String"), env->NewStringUTF(""));
+
+    for (size_t i = 0; i < list_size; i++)
+        env->SetObjectArrayElement(available_layouts, i, env->NewStringUTF(native_data[i]));
+
+    return available_layouts;
+}
+
 /*
  * Class:     com_android_framebufferizer_NativeRenderer
  * Method:    setConfimationMessage
@@ -206,5 +238,18 @@ extern "C" JNIEXPORT void JNICALL
 Java_com_android_framebufferizer_NativeRenderer_setConfimationMessage(
     JNIEnv* env, jclass, jstring jConfirmationMessage) {
     JString confirmationMessage(env, jConfirmationMessage);
-    setConfirmationMessage(confirmationMessage.begin());
+    if (sCurrentExample) sCurrentExample->setConfirmationMessage(confirmationMessage.begin());
 }
+
+/*
+ * Class:     com_android_framebufferizer_NativeRenderer
+ * Method:    onEvent
+ * Signature: (III)I
+ */
+extern "C" JNIEXPORT jint JNICALL Java_com_android_framebufferizer_NativeRenderer_onEvent(
+    JNIEnv*, jclass, jint x, jint y, jint event) {
+    if (sCurrentExample) {
+        return (jint)sCurrentExample->onEvent((uint32_t)x, (uint32_t)y, (uint32_t)event);
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/test/include/teeui/test/teeui_render_test.h b/test/include/teeui/test/teeui_render_test.h
index e405032..cc28afd 100644
--- a/test/include/teeui/test/teeui_render_test.h
+++ b/test/include/teeui/test/teeui_render_test.h
@@ -23,7 +23,8 @@ namespace test {
 // Initializes the test with the device configuration with command line params.
 extern void initRenderTest(int argc, char** argv);
 
-extern int runRenderTest(const char* language, bool magnified);
+extern int runRenderTest(const char* language, bool magnified, bool inverted = false,
+                         const char* confirmationMessage = "", const char* layout = "");
 
 }  // namespace test
 
diff --git a/test/teeui_device_config.cpp b/test/teeui_device_config.cpp
index 5d271bb..ff8bf71 100644
--- a/test/teeui_device_config.cpp
+++ b/test/teeui_device_config.cpp
@@ -19,7 +19,7 @@
 #include <iostream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <teeui/example/teeui.h>
+#include <teeui/example/example.h>
 #include <unistd.h>
 
 #include "teeui_device_config.h"
@@ -31,20 +31,29 @@ namespace teeui {
 
 namespace test {
 
+using namespace example;
+
 void initRenderTest(int argc, char** argv) {
     ::teeui::test::TeeuiRenderTest::Instance()->initFromOptions(argc, argv);
 }
 
-int runRenderTest(const char* language, bool magnified) {
+int runRenderTest(const char* language, bool magnified, bool inverted,
+                  const char* confirmationMessage, const char* layout) {
+    std::unique_ptr<ITeeuiExample> sCurrentExample = createExample(
+        (strcmp(layout, kTouchButtonLayout) == 0) ? Examples::TouchButton : Examples::PhysButton);
+
     DeviceInfo* device_info_ptr = &TeeuiRenderTest::Instance()->device_info;
-    selectLanguage(language);
-    setDeviceInfo(*device_info_ptr, magnified);
+    sCurrentExample->setDeviceInfo(*device_info_ptr, magnified, inverted);
     uint32_t w = device_info_ptr->width_;
     uint32_t h = device_info_ptr->height_;
     uint32_t linestride = w;
     uint32_t buffer_size = h * linestride;
     std::vector<uint32_t> buffer(buffer_size);
-    int error = renderUIIntoBuffer(0, 0, w, h, linestride, buffer.data(), buffer_size);
+    sCurrentExample->setConfirmationMessage(confirmationMessage);
+    sCurrentExample->selectLanguage(language);
+
+    int error =
+        sCurrentExample->renderUIIntoBuffer(0, 0, w, h, linestride, buffer.data(), buffer_size);
     return error;
 }
 
diff --git a/test/teeui_device_config.h b/test/teeui_device_config.h
index 58cb2cd..7bcfa5a 100644
--- a/test/teeui_device_config.h
+++ b/test/teeui_device_config.h
@@ -21,7 +21,7 @@
 #include <iostream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <teeui/example/teeui.h>
+#include <teeui/example/example.h>
 #include <unistd.h>
 
 #include <teeui/test/teeui_render_test.h>
@@ -35,7 +35,7 @@ namespace test {
 class TeeuiRenderTest : public ::testing::Test {
   public:
     // Default device configuration set to Blueline
-    DeviceInfo device_info = {
+    example::DeviceInfo device_info = {
         1080,         // width in px
         2160,         // height om px
         2.62135,      // dp2px pixel per density independent pixel
diff --git a/test/teeui_draw_label_text_test.cpp b/test/teeui_draw_label_text_test.cpp
index e37d8c0..1f08551 100644
--- a/test/teeui_draw_label_text_test.cpp
+++ b/test/teeui_draw_label_text_test.cpp
@@ -14,14 +14,12 @@
  * limitations under the License.
  */
 
-/* Generated by generate_teeui_render_tests - DO NOT EDIT */
-
 #include <getopt.h>
 #include <gtest/gtest.h>
 #include <iostream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <teeui/example/teeui.h>
+#include <teeui/example/example.h>
 #include <unistd.h>
 
 #include "teeui_device_config.h"
@@ -43,39 +41,67 @@ static constexpr const char kText100Character1Group[] =
 
 class TeeuiDrawLabelTextTest : public ::testing::Test {};
 
-TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group) {
-    setConfirmationMessage(kText12Character8Group);
-    int error = runRenderTest("en", false /* magnified */);
+TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_phys_button_layout) {
+    int error = runRenderTest("en", false /* magnified */, &kText12Character8Group[0]);
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_phys_button_layout_magnified) {
+    int error = runRenderTest("en", true /* magnified */, &kText12Character8Group[0]);
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_phys_button_layout) {
+    int error = runRenderTest("en", false /* magnified */, &kText100Character1Group[0]);
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_phys_button_layout_magnified) {
+    int error = runRenderTest("en", true /* magnified */, &kText100Character1Group[0]);
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_phys_button_layout) {
+    int error = runRenderTest("en", false /* magnified */, "");
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_phys_button_layout_magnified) {
+    int error = runRenderTest("en", true /* magnified */, "");
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_touch_button_layout) {
+    int error = runRenderTest("en", false /* magnified */, &kText12Character8Group[0],
+                              example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_M) {
-    setConfirmationMessage(kText12Character8Group);
-    int error = runRenderTest("en", true /* magnified */);
+TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_touch_button_layout_magnified) {
+    int error = runRenderTest("en", true /* magnified */, &kText12Character8Group[0],
+                              example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group) {
-    setConfirmationMessage(kText100Character1Group);
-    int error = runRenderTest("en", false /* magnified */);
+TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_touch_button_layout) {
+    int error = runRenderTest("en", false /* magnified */, &kText100Character1Group[0],
+                              example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_M) {
-    setConfirmationMessage(kText100Character1Group);
-    int error = runRenderTest("en", true /* magnified */);
+TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_touch_button_layout_magnified) {
+    int error = runRenderTest("en", true /* magnified */, &kText100Character1Group[0],
+                              example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiDrawLabelTextTest, Test_empty_text) {
-    setConfirmationMessage("");
-    int error = runRenderTest("en", false /* magnified */);
+TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_touch_button_layout) {
+    int error = runRenderTest("en", false /* magnified */, "", example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_M) {
-    setConfirmationMessage("");
-    int error = runRenderTest("en", true /* magnified */);
+TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_touch_button_layout_magnified) {
+    int error = runRenderTest("en", true /* magnified */, "", example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
diff --git a/test/teeui_locale_test.cpp b/test/teeui_locale_test.cpp
index dfd568e..c81921b 100644
--- a/test/teeui_locale_test.cpp
+++ b/test/teeui_locale_test.cpp
@@ -21,7 +21,7 @@
 #include <iostream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <teeui/example/teeui.h>
+#include <teeui/example/example.h>
 #include <unistd.h>
 
 #include "teeui_device_config.h"
@@ -40,7 +40,7 @@ TEST_F(TeeuiLocaleTest, Test_en) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_en_M) {
+TEST_F(TeeuiLocaleTest, Test_en_magnified) {
     int error = runRenderTest("en", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -50,7 +50,7 @@ TEST_F(TeeuiLocaleTest, Test_AF) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AF_M) {
+TEST_F(TeeuiLocaleTest, Test_AF_magnified) {
     int error = runRenderTest("af", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -60,7 +60,7 @@ TEST_F(TeeuiLocaleTest, Test_AM) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AM_M) {
+TEST_F(TeeuiLocaleTest, Test_AM_magnified) {
     int error = runRenderTest("am", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -70,7 +70,7 @@ TEST_F(TeeuiLocaleTest, Test_AR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AR_M) {
+TEST_F(TeeuiLocaleTest, Test_AR_magnified) {
     int error = runRenderTest("ar", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -80,7 +80,7 @@ TEST_F(TeeuiLocaleTest, Test_AR_EG) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AR_EG_M) {
+TEST_F(TeeuiLocaleTest, Test_AR_EG_magnified) {
     int error = runRenderTest("ar-EG", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -90,7 +90,7 @@ TEST_F(TeeuiLocaleTest, Test_AR_JO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AR_JO_M) {
+TEST_F(TeeuiLocaleTest, Test_AR_JO_magnified) {
     int error = runRenderTest("ar-JO", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -100,7 +100,7 @@ TEST_F(TeeuiLocaleTest, Test_AR_MA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AR_MA_M) {
+TEST_F(TeeuiLocaleTest, Test_AR_MA_magnified) {
     int error = runRenderTest("ar-MA", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -110,7 +110,7 @@ TEST_F(TeeuiLocaleTest, Test_AR_SA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AR_SA_M) {
+TEST_F(TeeuiLocaleTest, Test_AR_SA_magnified) {
     int error = runRenderTest("ar-SA", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -120,7 +120,7 @@ TEST_F(TeeuiLocaleTest, Test_AR_XB) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AR_XB_M) {
+TEST_F(TeeuiLocaleTest, Test_AR_XB_magnified) {
     int error = runRenderTest("ar-XB", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -130,7 +130,7 @@ TEST_F(TeeuiLocaleTest, Test_AS) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AS_M) {
+TEST_F(TeeuiLocaleTest, Test_AS_magnified) {
     int error = runRenderTest("as", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -140,7 +140,7 @@ TEST_F(TeeuiLocaleTest, Test_AZ) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_AZ_M) {
+TEST_F(TeeuiLocaleTest, Test_AZ_magnified) {
     int error = runRenderTest("az", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -150,7 +150,7 @@ TEST_F(TeeuiLocaleTest, Test_BE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_BE_M) {
+TEST_F(TeeuiLocaleTest, Test_BE_magnified) {
     int error = runRenderTest("be", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -160,7 +160,7 @@ TEST_F(TeeuiLocaleTest, Test_BG) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_BG_M) {
+TEST_F(TeeuiLocaleTest, Test_BG_magnified) {
     int error = runRenderTest("bg", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -170,7 +170,7 @@ TEST_F(TeeuiLocaleTest, Test_BN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_BN_M) {
+TEST_F(TeeuiLocaleTest, Test_BN_magnified) {
     int error = runRenderTest("bn", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -180,7 +180,7 @@ TEST_F(TeeuiLocaleTest, Test_BS) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_BS_M) {
+TEST_F(TeeuiLocaleTest, Test_BS_magnified) {
     int error = runRenderTest("bs", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -190,7 +190,7 @@ TEST_F(TeeuiLocaleTest, Test_CA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_CA_M) {
+TEST_F(TeeuiLocaleTest, Test_CA_magnified) {
     int error = runRenderTest("ca", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -200,7 +200,7 @@ TEST_F(TeeuiLocaleTest, Test_CS) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_CS_M) {
+TEST_F(TeeuiLocaleTest, Test_CS_magnified) {
     int error = runRenderTest("cs", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -210,7 +210,7 @@ TEST_F(TeeuiLocaleTest, Test_DA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_DA_M) {
+TEST_F(TeeuiLocaleTest, Test_DA_magnified) {
     int error = runRenderTest("da", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -220,7 +220,7 @@ TEST_F(TeeuiLocaleTest, Test_DE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_DE_M) {
+TEST_F(TeeuiLocaleTest, Test_DE_magnified) {
     int error = runRenderTest("de", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -230,7 +230,7 @@ TEST_F(TeeuiLocaleTest, Test_DE_AT) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_DE_AT_M) {
+TEST_F(TeeuiLocaleTest, Test_DE_AT_magnified) {
     int error = runRenderTest("de-AT", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -240,7 +240,7 @@ TEST_F(TeeuiLocaleTest, Test_DE_CH) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_DE_CH_M) {
+TEST_F(TeeuiLocaleTest, Test_DE_CH_magnified) {
     int error = runRenderTest("de-CH", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -250,7 +250,7 @@ TEST_F(TeeuiLocaleTest, Test_EL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EL_M) {
+TEST_F(TeeuiLocaleTest, Test_EL_magnified) {
     int error = runRenderTest("el", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -260,7 +260,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_AU) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_AU_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_AU_magnified) {
     int error = runRenderTest("en-AU", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -270,7 +270,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_CA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_CA_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_CA_magnified) {
     int error = runRenderTest("en-CA", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -280,7 +280,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_GB) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_GB_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_GB_magnified) {
     int error = runRenderTest("en-GB", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -290,7 +290,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_IE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_IE_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_IE_magnified) {
     int error = runRenderTest("en-IE", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -300,7 +300,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_IN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_IN_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_IN_magnified) {
     int error = runRenderTest("en-IN", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -310,7 +310,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_NZ) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_NZ_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_NZ_magnified) {
     int error = runRenderTest("en-NZ", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -320,7 +320,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_SG) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_SG_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_SG_magnified) {
     int error = runRenderTest("en-SG", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -330,7 +330,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_XA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_XA_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_XA_magnified) {
     int error = runRenderTest("en-XA", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -340,7 +340,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_XC) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_XC_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_XC_magnified) {
     int error = runRenderTest("en-XC", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -350,7 +350,7 @@ TEST_F(TeeuiLocaleTest, Test_EN_ZA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EN_ZA_M) {
+TEST_F(TeeuiLocaleTest, Test_EN_ZA_magnified) {
     int error = runRenderTest("en-ZA", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -360,7 +360,7 @@ TEST_F(TeeuiLocaleTest, Test_ES) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_magnified) {
     int error = runRenderTest("es", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -370,7 +370,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_419) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_419_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_419_magnified) {
     int error = runRenderTest("es-419", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -380,7 +380,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_AR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_AR_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_AR_magnified) {
     int error = runRenderTest("es-AR", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -390,7 +390,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_BO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_BO_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_BO_magnified) {
     int error = runRenderTest("es-BO", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -400,7 +400,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_CL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_CL_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_CL_magnified) {
     int error = runRenderTest("es-CL", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -410,7 +410,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_CO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_CO_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_CO_magnified) {
     int error = runRenderTest("es-CO", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -420,7 +420,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_CR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_CR_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_CR_magnified) {
     int error = runRenderTest("es-CR", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -430,7 +430,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_DO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_DO_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_DO_magnified) {
     int error = runRenderTest("es-DO", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -440,7 +440,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_EC) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_EC_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_EC_magnified) {
     int error = runRenderTest("es-EC", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -450,7 +450,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_GT) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_GT_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_GT_magnified) {
     int error = runRenderTest("es-GT", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -460,7 +460,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_HN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_HN_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_HN_magnified) {
     int error = runRenderTest("es-HN", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -470,7 +470,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_MX) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_MX_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_MX_magnified) {
     int error = runRenderTest("es-MX", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -480,7 +480,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_NI) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_NI_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_NI_magnified) {
     int error = runRenderTest("es-NI", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -490,7 +490,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_PA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_PA_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_PA_magnified) {
     int error = runRenderTest("es-PA", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -500,7 +500,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_PE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_PE_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_PE_magnified) {
     int error = runRenderTest("es-PE", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -510,7 +510,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_PR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_PR_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_PR_magnified) {
     int error = runRenderTest("es-PR", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -520,7 +520,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_PY) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_PY_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_PY_magnified) {
     int error = runRenderTest("es-PY", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -530,7 +530,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_SV) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_SV_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_SV_magnified) {
     int error = runRenderTest("es-SV", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -540,7 +540,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_US) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_US_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_US_magnified) {
     int error = runRenderTest("es-US", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -550,7 +550,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_UY) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_UY_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_UY_magnified) {
     int error = runRenderTest("es-UY", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -560,7 +560,7 @@ TEST_F(TeeuiLocaleTest, Test_ES_VE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ES_VE_M) {
+TEST_F(TeeuiLocaleTest, Test_ES_VE_magnified) {
     int error = runRenderTest("es-VE", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -570,7 +570,7 @@ TEST_F(TeeuiLocaleTest, Test_ET) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ET_M) {
+TEST_F(TeeuiLocaleTest, Test_ET_magnified) {
     int error = runRenderTest("et", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -580,7 +580,7 @@ TEST_F(TeeuiLocaleTest, Test_EU) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_EU_M) {
+TEST_F(TeeuiLocaleTest, Test_EU_magnified) {
     int error = runRenderTest("eu", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -590,7 +590,7 @@ TEST_F(TeeuiLocaleTest, Test_FA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_FA_M) {
+TEST_F(TeeuiLocaleTest, Test_FA_magnified) {
     int error = runRenderTest("fa", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -600,7 +600,7 @@ TEST_F(TeeuiLocaleTest, Test_FI) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_FI_M) {
+TEST_F(TeeuiLocaleTest, Test_FI_magnified) {
     int error = runRenderTest("fi", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -610,7 +610,7 @@ TEST_F(TeeuiLocaleTest, Test_FIL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_FIL_M) {
+TEST_F(TeeuiLocaleTest, Test_FIL_magnified) {
     int error = runRenderTest("fil", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -620,7 +620,7 @@ TEST_F(TeeuiLocaleTest, Test_FR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_FR_M) {
+TEST_F(TeeuiLocaleTest, Test_FR_magnified) {
     int error = runRenderTest("fr", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -630,7 +630,7 @@ TEST_F(TeeuiLocaleTest, Test_FR_CA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_FR_CA_M) {
+TEST_F(TeeuiLocaleTest, Test_FR_CA_magnified) {
     int error = runRenderTest("fr-CA", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -640,7 +640,7 @@ TEST_F(TeeuiLocaleTest, Test_FR_CH) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_FR_CH_M) {
+TEST_F(TeeuiLocaleTest, Test_FR_CH_magnified) {
     int error = runRenderTest("fr-CH", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -650,7 +650,7 @@ TEST_F(TeeuiLocaleTest, Test_GL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_GL_M) {
+TEST_F(TeeuiLocaleTest, Test_GL_magnified) {
     int error = runRenderTest("gl", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -660,7 +660,7 @@ TEST_F(TeeuiLocaleTest, Test_GSW) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_GSW_M) {
+TEST_F(TeeuiLocaleTest, Test_GSW_magnified) {
     int error = runRenderTest("gsw", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -670,7 +670,7 @@ TEST_F(TeeuiLocaleTest, Test_GU) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_GU_M) {
+TEST_F(TeeuiLocaleTest, Test_GU_magnified) {
     int error = runRenderTest("gu", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -680,7 +680,7 @@ TEST_F(TeeuiLocaleTest, Test_HE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_HE_M) {
+TEST_F(TeeuiLocaleTest, Test_HE_magnified) {
     int error = runRenderTest("he", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -690,7 +690,7 @@ TEST_F(TeeuiLocaleTest, Test_HI) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_HI_M) {
+TEST_F(TeeuiLocaleTest, Test_HI_magnified) {
     int error = runRenderTest("hi", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -700,7 +700,7 @@ TEST_F(TeeuiLocaleTest, Test_HR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_HR_M) {
+TEST_F(TeeuiLocaleTest, Test_HR_magnified) {
     int error = runRenderTest("hr", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -710,7 +710,7 @@ TEST_F(TeeuiLocaleTest, Test_HU) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_HU_M) {
+TEST_F(TeeuiLocaleTest, Test_HU_magnified) {
     int error = runRenderTest("hu", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -720,7 +720,7 @@ TEST_F(TeeuiLocaleTest, Test_HY) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_HY_M) {
+TEST_F(TeeuiLocaleTest, Test_HY_magnified) {
     int error = runRenderTest("hy", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -730,7 +730,7 @@ TEST_F(TeeuiLocaleTest, Test_ID) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ID_M) {
+TEST_F(TeeuiLocaleTest, Test_ID_magnified) {
     int error = runRenderTest("id", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -740,7 +740,7 @@ TEST_F(TeeuiLocaleTest, Test_IN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_IN_M) {
+TEST_F(TeeuiLocaleTest, Test_IN_magnified) {
     int error = runRenderTest("in", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -750,7 +750,7 @@ TEST_F(TeeuiLocaleTest, Test_IS) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_IS_M) {
+TEST_F(TeeuiLocaleTest, Test_IS_magnified) {
     int error = runRenderTest("is", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -760,7 +760,7 @@ TEST_F(TeeuiLocaleTest, Test_IT) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_IT_M) {
+TEST_F(TeeuiLocaleTest, Test_IT_magnified) {
     int error = runRenderTest("it", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -770,7 +770,7 @@ TEST_F(TeeuiLocaleTest, Test_IW) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_IW_M) {
+TEST_F(TeeuiLocaleTest, Test_IW_magnified) {
     int error = runRenderTest("iw", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -780,7 +780,7 @@ TEST_F(TeeuiLocaleTest, Test_JA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_JA_M) {
+TEST_F(TeeuiLocaleTest, Test_JA_magnified) {
     int error = runRenderTest("ja", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -790,7 +790,7 @@ TEST_F(TeeuiLocaleTest, Test_KA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_KA_M) {
+TEST_F(TeeuiLocaleTest, Test_KA_magnified) {
     int error = runRenderTest("ka", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -800,7 +800,7 @@ TEST_F(TeeuiLocaleTest, Test_KK) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_KK_M) {
+TEST_F(TeeuiLocaleTest, Test_KK_magnified) {
     int error = runRenderTest("kk", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -810,7 +810,7 @@ TEST_F(TeeuiLocaleTest, Test_KM) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_KM_M) {
+TEST_F(TeeuiLocaleTest, Test_KM_magnified) {
     int error = runRenderTest("km", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -820,7 +820,7 @@ TEST_F(TeeuiLocaleTest, Test_KN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_KN_M) {
+TEST_F(TeeuiLocaleTest, Test_KN_magnified) {
     int error = runRenderTest("kn", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -830,7 +830,7 @@ TEST_F(TeeuiLocaleTest, Test_KO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_KO_M) {
+TEST_F(TeeuiLocaleTest, Test_KO_magnified) {
     int error = runRenderTest("ko", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -840,7 +840,7 @@ TEST_F(TeeuiLocaleTest, Test_KY) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_KY_M) {
+TEST_F(TeeuiLocaleTest, Test_KY_magnified) {
     int error = runRenderTest("ky", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -850,7 +850,7 @@ TEST_F(TeeuiLocaleTest, Test_LN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_LN_M) {
+TEST_F(TeeuiLocaleTest, Test_LN_magnified) {
     int error = runRenderTest("ln", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -860,7 +860,7 @@ TEST_F(TeeuiLocaleTest, Test_LO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_LO_M) {
+TEST_F(TeeuiLocaleTest, Test_LO_magnified) {
     int error = runRenderTest("lo", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -870,7 +870,7 @@ TEST_F(TeeuiLocaleTest, Test_LT) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_LT_M) {
+TEST_F(TeeuiLocaleTest, Test_LT_magnified) {
     int error = runRenderTest("lt", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -880,7 +880,7 @@ TEST_F(TeeuiLocaleTest, Test_LV) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_LV_M) {
+TEST_F(TeeuiLocaleTest, Test_LV_magnified) {
     int error = runRenderTest("lv", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -890,7 +890,7 @@ TEST_F(TeeuiLocaleTest, Test_MK) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_MK_M) {
+TEST_F(TeeuiLocaleTest, Test_MK_magnified) {
     int error = runRenderTest("mk", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -900,7 +900,7 @@ TEST_F(TeeuiLocaleTest, Test_ML) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ML_M) {
+TEST_F(TeeuiLocaleTest, Test_ML_magnified) {
     int error = runRenderTest("ml", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -910,7 +910,7 @@ TEST_F(TeeuiLocaleTest, Test_MN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_MN_M) {
+TEST_F(TeeuiLocaleTest, Test_MN_magnified) {
     int error = runRenderTest("mn", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -920,7 +920,7 @@ TEST_F(TeeuiLocaleTest, Test_MO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_MO_M) {
+TEST_F(TeeuiLocaleTest, Test_MO_magnified) {
     int error = runRenderTest("mo", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -930,7 +930,7 @@ TEST_F(TeeuiLocaleTest, Test_MR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_MR_M) {
+TEST_F(TeeuiLocaleTest, Test_MR_magnified) {
     int error = runRenderTest("mr", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -940,7 +940,7 @@ TEST_F(TeeuiLocaleTest, Test_MS) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_MS_M) {
+TEST_F(TeeuiLocaleTest, Test_MS_magnified) {
     int error = runRenderTest("ms", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -950,7 +950,7 @@ TEST_F(TeeuiLocaleTest, Test_MY) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_MY_M) {
+TEST_F(TeeuiLocaleTest, Test_MY_magnified) {
     int error = runRenderTest("my", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -960,7 +960,7 @@ TEST_F(TeeuiLocaleTest, Test_NB) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_NB_M) {
+TEST_F(TeeuiLocaleTest, Test_NB_magnified) {
     int error = runRenderTest("nb", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -970,7 +970,7 @@ TEST_F(TeeuiLocaleTest, Test_NE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_NE_M) {
+TEST_F(TeeuiLocaleTest, Test_NE_magnified) {
     int error = runRenderTest("ne", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -980,7 +980,7 @@ TEST_F(TeeuiLocaleTest, Test_NL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_NL_M) {
+TEST_F(TeeuiLocaleTest, Test_NL_magnified) {
     int error = runRenderTest("nl", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -990,7 +990,7 @@ TEST_F(TeeuiLocaleTest, Test_NO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_NO_M) {
+TEST_F(TeeuiLocaleTest, Test_NO_magnified) {
     int error = runRenderTest("no", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1000,7 +1000,7 @@ TEST_F(TeeuiLocaleTest, Test_OR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_OR_M) {
+TEST_F(TeeuiLocaleTest, Test_OR_magnified) {
     int error = runRenderTest("or", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1010,7 +1010,7 @@ TEST_F(TeeuiLocaleTest, Test_PA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_PA_M) {
+TEST_F(TeeuiLocaleTest, Test_PA_magnified) {
     int error = runRenderTest("pa", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1020,7 +1020,7 @@ TEST_F(TeeuiLocaleTest, Test_PL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_PL_M) {
+TEST_F(TeeuiLocaleTest, Test_PL_magnified) {
     int error = runRenderTest("pl", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1030,7 +1030,7 @@ TEST_F(TeeuiLocaleTest, Test_PT) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_PT_M) {
+TEST_F(TeeuiLocaleTest, Test_PT_magnified) {
     int error = runRenderTest("pt", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1040,7 +1040,7 @@ TEST_F(TeeuiLocaleTest, Test_PT_BR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_PT_BR_M) {
+TEST_F(TeeuiLocaleTest, Test_PT_BR_magnified) {
     int error = runRenderTest("pt-BR", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1050,7 +1050,7 @@ TEST_F(TeeuiLocaleTest, Test_PT_PT) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_PT_PT_M) {
+TEST_F(TeeuiLocaleTest, Test_PT_PT_magnified) {
     int error = runRenderTest("pt-PT", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1060,7 +1060,7 @@ TEST_F(TeeuiLocaleTest, Test_RO) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_RO_M) {
+TEST_F(TeeuiLocaleTest, Test_RO_magnified) {
     int error = runRenderTest("ro", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1070,7 +1070,7 @@ TEST_F(TeeuiLocaleTest, Test_RU) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_RU_M) {
+TEST_F(TeeuiLocaleTest, Test_RU_magnified) {
     int error = runRenderTest("ru", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1080,7 +1080,7 @@ TEST_F(TeeuiLocaleTest, Test_SI) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SI_M) {
+TEST_F(TeeuiLocaleTest, Test_SI_magnified) {
     int error = runRenderTest("si", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1090,7 +1090,7 @@ TEST_F(TeeuiLocaleTest, Test_SK) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SK_M) {
+TEST_F(TeeuiLocaleTest, Test_SK_magnified) {
     int error = runRenderTest("sk", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1100,7 +1100,7 @@ TEST_F(TeeuiLocaleTest, Test_SL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SL_M) {
+TEST_F(TeeuiLocaleTest, Test_SL_magnified) {
     int error = runRenderTest("sl", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1110,7 +1110,7 @@ TEST_F(TeeuiLocaleTest, Test_SQ) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SQ_M) {
+TEST_F(TeeuiLocaleTest, Test_SQ_magnified) {
     int error = runRenderTest("sq", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1120,7 +1120,7 @@ TEST_F(TeeuiLocaleTest, Test_SR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SR_M) {
+TEST_F(TeeuiLocaleTest, Test_SR_magnified) {
     int error = runRenderTest("sr", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1130,7 +1130,7 @@ TEST_F(TeeuiLocaleTest, Test_SR_LATN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SR_LATN_M) {
+TEST_F(TeeuiLocaleTest, Test_SR_LATN_magnified) {
     int error = runRenderTest("sr-Latn", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1140,7 +1140,7 @@ TEST_F(TeeuiLocaleTest, Test_SV) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SV_M) {
+TEST_F(TeeuiLocaleTest, Test_SV_magnified) {
     int error = runRenderTest("sv", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1150,7 +1150,7 @@ TEST_F(TeeuiLocaleTest, Test_SW) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_SW_M) {
+TEST_F(TeeuiLocaleTest, Test_SW_magnified) {
     int error = runRenderTest("sw", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1160,7 +1160,7 @@ TEST_F(TeeuiLocaleTest, Test_TA) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_TA_M) {
+TEST_F(TeeuiLocaleTest, Test_TA_magnified) {
     int error = runRenderTest("ta", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1170,7 +1170,7 @@ TEST_F(TeeuiLocaleTest, Test_TE) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_TE_M) {
+TEST_F(TeeuiLocaleTest, Test_TE_magnified) {
     int error = runRenderTest("te", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1180,7 +1180,7 @@ TEST_F(TeeuiLocaleTest, Test_TH) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_TH_M) {
+TEST_F(TeeuiLocaleTest, Test_TH_magnified) {
     int error = runRenderTest("th", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1190,7 +1190,7 @@ TEST_F(TeeuiLocaleTest, Test_TL) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_TL_M) {
+TEST_F(TeeuiLocaleTest, Test_TL_magnified) {
     int error = runRenderTest("tl", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1200,7 +1200,7 @@ TEST_F(TeeuiLocaleTest, Test_TR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_TR_M) {
+TEST_F(TeeuiLocaleTest, Test_TR_magnified) {
     int error = runRenderTest("tr", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1210,7 +1210,7 @@ TEST_F(TeeuiLocaleTest, Test_UK) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_UK_M) {
+TEST_F(TeeuiLocaleTest, Test_UK_magnified) {
     int error = runRenderTest("uk", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1220,7 +1220,7 @@ TEST_F(TeeuiLocaleTest, Test_UR) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_UR_M) {
+TEST_F(TeeuiLocaleTest, Test_UR_magnified) {
     int error = runRenderTest("ur", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1230,7 +1230,7 @@ TEST_F(TeeuiLocaleTest, Test_UZ) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_UZ_M) {
+TEST_F(TeeuiLocaleTest, Test_UZ_magnified) {
     int error = runRenderTest("uz", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1240,7 +1240,7 @@ TEST_F(TeeuiLocaleTest, Test_VI) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_VI_M) {
+TEST_F(TeeuiLocaleTest, Test_VI_magnified) {
     int error = runRenderTest("vi", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1250,7 +1250,7 @@ TEST_F(TeeuiLocaleTest, Test_ZH) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ZH_M) {
+TEST_F(TeeuiLocaleTest, Test_ZH_magnified) {
     int error = runRenderTest("zh", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1260,7 +1260,7 @@ TEST_F(TeeuiLocaleTest, Test_ZH_CN) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ZH_CN_M) {
+TEST_F(TeeuiLocaleTest, Test_ZH_CN_magnified) {
     int error = runRenderTest("zh-CN", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1270,7 +1270,7 @@ TEST_F(TeeuiLocaleTest, Test_ZH_HK) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ZH_HK_M) {
+TEST_F(TeeuiLocaleTest, Test_ZH_HK_magnified) {
     int error = runRenderTest("zh-HK", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1280,7 +1280,7 @@ TEST_F(TeeuiLocaleTest, Test_ZH_TW) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ZH_TW_M) {
+TEST_F(TeeuiLocaleTest, Test_ZH_TW_magnified) {
     int error = runRenderTest("zh-TW", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
@@ -1290,7 +1290,7 @@ TEST_F(TeeuiLocaleTest, Test_ZU) {
     ASSERT_EQ(error, 0);
 }
 
-TEST_F(TeeuiLocaleTest, Test_ZU_M) {
+TEST_F(TeeuiLocaleTest, Test_ZU_magnified) {
     int error = runRenderTest("zu", true /* magnified */);
     ASSERT_EQ(error, 0);
 }
diff --git a/tools/framebufferizer/src/com/android/framebufferizer/NativeRenderer.java b/tools/framebufferizer/src/com/android/framebufferizer/NativeRenderer.java
index eca320e..991e61b 100644
--- a/tools/framebufferizer/src/com/android/framebufferizer/NativeRenderer.java
+++ b/tools/framebufferizer/src/com/android/framebufferizer/NativeRenderer.java
@@ -23,9 +23,11 @@ public class NativeRenderer {
          System.loadLibrary("teeui_jni");
     }
 
-    public static native int setDeviceInfo(DeviceInfo deviceInfo, boolean magnified, boolean inverted);
+    public static native int setDeviceInfo(DeviceInfo deviceInfo, boolean magnified, boolean inverted, String touchLayout);
     public static native int renderBuffer(int x, int y, int width, int height, int lineStride, int[] buffer);
     public static native void setLanguage(String language_id);
     public static native String[] getLanguageIdList();
     public static native void setConfimationMessage(String confimationMessage);
+    public static native int onEvent(int x, int y, int event);
+    public static native String[] getAvailableLayouts();
 }
diff --git a/tools/framebufferizer/src/com/android/framebufferizer/utils/Config.java b/tools/framebufferizer/src/com/android/framebufferizer/utils/Config.java
index 708551c..9e5baed 100644
--- a/tools/framebufferizer/src/com/android/framebufferizer/utils/Config.java
+++ b/tools/framebufferizer/src/com/android/framebufferizer/utils/Config.java
@@ -30,6 +30,7 @@ import org.json.JSONException;
 public class Config {
     public static final String KEY_MAGNIFIED = "magnified";
     public static final String KEY_INVERTED = "inverted";
+    public static final String KEY_LAYOUT = "layout";
     public static final String KEY_LOCALE = "locale";
     public static final String KEY_DEVICE = "device";
     public static final String KEY_MESSAGE = "message";
diff --git a/tools/framebufferizer/src/com/android/framebufferizer/utils/FrameBufferBuffer.java b/tools/framebufferizer/src/com/android/framebufferizer/utils/FrameBufferBuffer.java
index e627e47..a81e1db 100644
--- a/tools/framebufferizer/src/com/android/framebufferizer/utils/FrameBufferBuffer.java
+++ b/tools/framebufferizer/src/com/android/framebufferizer/utils/FrameBufferBuffer.java
@@ -17,30 +17,23 @@
 package com.android.framebufferizer.utils;
 
 import com.android.framebufferizer.NativeRenderer;
-
-import java.awt.*;
-import java.awt.event.ComponentEvent;
-import java.awt.event.ComponentListener;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseMotionListener;
-import java.awt.event.ActionListener;
-import java.awt.event.ActionEvent;
 import java.awt.geom.AffineTransform;
 import java.awt.image.BufferedImage;
-import java.awt.image.ColorModel;
 import java.awt.image.DataBufferInt;
-import java.awt.image.DirectColorModel;
-import java.awt.image.Raster;
 import java.awt.image.RenderedImage;
-import java.awt.image.WritableRaster;
-import java.io.*;
-import java.util.Map;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.Set;
-
+import java.awt.image.ColorModel;
+import java.awt.image.DirectColorModel;
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
 import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
 
-public class FrameBufferBuffer extends JPanel implements ComponentListener, MouseMotionListener {
+public class FrameBufferBuffer extends JPanel implements ComponentListener, MouseMotionListener,
+        MouseListener {
     public class MagnifiedView extends JPanel implements ComponentListener {
         private BufferedImage mImage;
 
@@ -91,6 +84,19 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
 
     }
 
+    public static enum EVENT_RESULT{
+        NONE(0), CONFIRM(1) ,CANCEL(2);
+        private int id;
+
+        EVENT_RESULT(int id){
+          this.id = id;
+        }
+
+        public int getValue(){
+          return id;
+        }
+    }
+
     public class ConfigSelector extends JPanel implements ActionListener {
         private final String languages[];
 
@@ -98,12 +104,16 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
             languages = NativeRenderer.getLanguageIdList();
         }
 
+        private final String layouts[] = NativeRenderer.getAvailableLayouts();
         private JComboBox<String> deviceSelector = new JComboBox(DeviceInfoDB.Device.values());
         private JCheckBox magnifiedCheckbox = new JCheckBox("Magnified");
         private JCheckBox invertedCheckbox = new JCheckBox("Inverted");
+
         private JComboBox<String> localeSelector = new JComboBox(languages);
         private JTextField confirmationMessage = new JTextField();
 
+        private JComboBox<String> layoutSelector = new JComboBox(layouts);
+
         protected ConfigSelector() {
             System.err.println("ConfigSelector");
             this.setLayout(new GridBagLayout());
@@ -139,23 +149,36 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
             c = new GridBagConstraints();
             c.gridx = 0;
             c.gridy = 2;
+            this.add(new JLabel("Select Layout:"), c);
+
+            layoutSelector.addActionListener(this);
+            c = new GridBagConstraints();
+            c.gridx = 1;
+            c.gridy = 2;
+            c.gridwidth = 2;
+            c.fill = GridBagConstraints.HORIZONTAL;
+            this.add(layoutSelector, c);
+
+            c = new GridBagConstraints();
+            c.gridx = 0;
+            c.gridy = 3;
             this.add(new JLabel("UIOptions:"), c);
 
             magnifiedCheckbox.addActionListener(this);
             c = new GridBagConstraints();
             c.gridx = 1;
-            c.gridy = 2;
+            c.gridy = 3;
             this.add(magnifiedCheckbox, c);
 
             invertedCheckbox.addActionListener(this);
             c = new GridBagConstraints();
             c.gridx = 2;
-            c.gridy = 2;
+            c.gridy = 3;
             this.add(invertedCheckbox, c);
 
             c = new GridBagConstraints();
             c.gridx = 0;
-            c.gridy = 3;
+            c.gridy = 4;
             this.add(new JLabel("Confirmation message:"), c);
 
             confirmationMessage.setText(
@@ -163,7 +186,7 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
             confirmationMessage.addActionListener(this);
             c = new GridBagConstraints();
             c.gridx = 1;
-            c.gridy = 3;
+            c.gridy = 4;
             c.fill = GridBagConstraints.BOTH;
             c.gridwidth = 2;
             this.add(confirmationMessage, c);
@@ -176,6 +199,7 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
             config.setValue(Config.KEY_MAGNIFIED, getConfigSelector().magnified());
             config.setValue(Config.KEY_INVERTED, getConfigSelector().inverted());
             config.setValue(Config.KEY_MESSAGE, getConfigSelector().confirmationMessage());
+            config.setValue(Config.KEY_LAYOUT, getConfigSelector().currentLayout());
         }
 
         public void actionPerformed(ActionEvent e) {
@@ -191,6 +215,10 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
             return (String) localeSelector.getSelectedItem();
         }
 
+        public String currentLayout() {
+            return (String) layoutSelector.getSelectedItem();
+        }
+
         public boolean magnified() {
             return magnifiedCheckbox.isSelected();
         }
@@ -209,6 +237,7 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
     private MagnifiedView mMagnifiedView;
     private ConfigSelector mConfigSelector;
     private JFrame mFrame;
+    private double mScale;
 
     public MagnifiedView getMagnifiedView() {
         if (mMagnifiedView == null) {
@@ -225,6 +254,36 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
     }
 
     @Override
+    public void mouseReleased(MouseEvent e) {
+        if (e.MOUSE_RELEASED == MouseEvent.MOUSE_RELEASED) {
+            double x = e.getPoint().x / mScale;
+            double y = e.getPoint().y / mScale;
+            int value = NativeRenderer.onEvent((int)x, (int)y, MouseEvent.MOUSE_RELEASED);
+            if(value == EVENT_RESULT.CONFIRM.getValue()){
+                JOptionPane.showMessageDialog((Component) e.getSource(), "Confirm clicked.");
+            } else if (value == EVENT_RESULT.CANCEL.getValue()){
+                JOptionPane.showMessageDialog((Component) e.getSource(), "Cancel clicked.");
+            }
+        }
+    }
+
+    @Override
+    public void mouseClicked(MouseEvent e){
+    }
+
+    @Override
+    public void mousePressed(MouseEvent e){
+    }
+
+    @Override
+    public void mouseEntered(MouseEvent e){
+    }
+
+    @Override
+    public void mouseExited(MouseEvent e){
+    }
+
+    @Override
     public void mouseDragged(MouseEvent e) {
 
     }
@@ -285,6 +344,9 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
                 case Config.KEY_MESSAGE:
                     getConfigSelector().confirmationMessage.setText((String) element.getValue());
                     break;
+                case Config.KEY_LAYOUT:
+                    getConfigSelector().layoutSelector.setSelectedItem((String) element.getValue());
+                    break;
                 }
             }
         }
@@ -297,6 +359,7 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
         renderNativeBuffer();
         addComponentListener(this);
         addMouseMotionListener(this);
+        addMouseListener(this);
     }
 
     @Override
@@ -332,11 +395,12 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
     }
 
     public void renderNativeBuffer() {
+        final int LAYOUT_EXAMPLE_ERROR = -2;
+        final int FRAME_BUFFER_ERROR = -1;
         DeviceInfo deviceInfo = DeviceInfoDB.getDeviceInfo(getConfigSelector().currentDevice());
         boolean magnified = getConfigSelector().magnified();
         boolean inverted = getConfigSelector().inverted();
-        NativeRenderer.setLanguage(getConfigSelector().currentLocale());
-        NativeRenderer.setConfimationMessage(getConfigSelector().confirmationMessage());
+
         int w = deviceInfo.getWidthPx();
         int h = deviceInfo.getHeightPx();
         final int linestride = w;
@@ -351,24 +415,29 @@ public class FrameBufferBuffer extends JPanel implements ComponentListener, Mous
                     new int[] { rMask, gMask, bMask }, null);
             ColorModel colorModel = new DirectColorModel(bpp, rMask, gMask, bMask);
             BufferedImage image = new BufferedImage(colorModel, raster, true, null);
-            NativeRenderer.setDeviceInfo(deviceInfo, magnified, inverted);
+            NativeRenderer.setDeviceInfo(deviceInfo, magnified, inverted, getConfigSelector().currentLayout());
+            NativeRenderer.setLanguage(getConfigSelector().currentLocale());
+            NativeRenderer.setConfimationMessage(getConfigSelector().confirmationMessage());
             error = NativeRenderer.renderBuffer(0, 0, w, h, linestride, mBuffer.getData());
-            if (error != 0) {
+            if(error == FRAME_BUFFER_ERROR){
+                System.out.println("Error framebuffer not initilized " + error);
+            } else if(error == LAYOUT_EXAMPLE_ERROR){
+                System.out.println("Error layout example not initilized " + error);
+            } else if (error != 0) {
                 System.out.println("Error rendering native buffer " + error);
             }
 
             mImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB_PRE);
             Graphics2D gc = mImage.createGraphics();
-            double scale = 0.0;
             if (w / (double) h > getWidth() / (double) getHeight()) {
-                scale = (double) getWidth() / (double) w;
+                mScale = (double) getWidth() / (double) w;
             } else {
-                scale = (double) getHeight() / (double) h;
+                mScale = (double) getHeight() / (double) h;
             }
             gc.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
             gc.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
             gc.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
-            gc.drawRenderedImage(image, AffineTransform.getScaleInstance(scale, scale));
+            gc.drawRenderedImage(image, AffineTransform.getScaleInstance(mScale, mScale));
         }
         repaint();
     }