class MyApp(App):
    def build(self):
        self.root = Root()
        return self.root

    def _run_prepare(self):
        from kivy.graphics import RenderContext, Canvas
        from kivy.core.window import Window
        canvas2 = Canvas()
        render_context2 = RenderContext()
        render_context2.add(canvas2)
        render_context2['projection_mat'] = Window.render_context['projection_mat']
        render_context2['modelview_mat'] = Window.render_context['modelview_mat']
        render_context2['frag_modelview_mat'] = Window.render_context['frag_modelview_mat']
        Window.apply_property(canvas2=ObjectProperty(canvas2))
        Window.apply_property(render_context2=ObjectProperty(render_context2))
        Window.update_viewport = types.MethodType(update_viewport, Window)
        Window.on_draw = types.MethodType(on_draw, Window)
        Window.on_draw2 = types.MethodType(on_draw2, Window)
        if not self.built:
            self.load_config()
            self.load_kv(filename=self.kv_file)
            root = self.build()
            if root:
                self.root = root
        if self.root:
            Window.add_widget(self.root)

        # Check if the window is already created
        from kivy.base import EventLoop
        window = EventLoop.window
        if window:
            self._app_window = window
            window.set_title(self.get_application_name())
            icon = self.get_application_icon()
            if icon:
                window.set_icon(icon)
            self._install_settings_keys(window)
        else:
            Logger.critical("Application: No window is created."
                            " Terminating application run.")
            return
        self.dispatch('on_start')

def update_viewport(self):
    from kivy.graphics.opengl import glViewport
    from kivy.graphics.transformation import Matrix
    from math import radians

    w, h = self._get_effective_size()

    smode = self.softinput_mode
    target = self._system_keyboard.target
    targettop = max(0, target.to_window(0, target.y)[1]) if target else 0
    kheight = self._kheight

    w2, h2 = w / 2., h / 2.
    r = radians(self.rotation)

    y = 0
    _h = h
    if smode == 'pan':
        y = kheight
    elif smode == 'below_target':
        y = 0 if kheight < targettop else (kheight - targettop)
    if smode == 'scale':
        _h -= kheight

    # prepare the viewport
    glViewport(0, 0, w, _h)

    # do projection matrix
    projection_mat = Matrix()
    projection_mat.view_clip(0.0, w, 0.0, h, -1.0, 1.0, 0)
    self.render_context['projection_mat'] = projection_mat
    self.render_context2['projection_mat'] = projection_mat

    # do modelview matrix
    modelview_mat = Matrix().translate(w2, h2, 0)
    modelview_mat = modelview_mat.multiply(Matrix().rotate(r, 0, 0, 1))

    w, h = self.size
    w2, h2 = w / 2., h / 2. - y
    modelview_mat = modelview_mat.multiply(Matrix().translate(-w2, -h2, 0))
    self.render_context['modelview_mat'] = modelview_mat
    self.render_context2['modelview_mat'] = modelview_mat
    frag_modelview_mat = Matrix()
    frag_modelview_mat.set(flat=modelview_mat.get())
    self.render_context['frag_modelview_mat'] = frag_modelview_mat
    self.render_context2['frag_modelview_mat'] = frag_modelview_mat

    # redraw canvas
    self.canvas.ask_update()
    self.canvas2.ask_update()

    # and update childs
    self.update_childsize()

def on_draw(self):
    self.clear()
    self.render_context.draw()
    self.render_context2.draw()

def on_draw2(self):
    self.render_context2.draw()