def render_led(self, led, color):

		# as a very basic quad for now!
		glPushMatrix()
		glTranslatef(led['x'], led['y'], self.config['size']['thickness']/2.0 + 0.1)  # 0.1mm in front of front face
		Renderer.quad(color, led['w'], led['h'])
		glPopMatrix()

def test_draw_action_method():
    renderer = Renderer()
    cmd = {"action": "draw", "magnitude": "100", "direction": "bd"}
    x, y = 230, 230
    renderer.draw_action(cmd, x, y)
    assert renderer.position == QPoint(230, 330)
    assert renderer.paths[-1].path_type == "line"

def render(template, context=None, **kwargs):
    """
    Return the given template string rendered using the given context.

    """
    renderer = Renderer()
    return renderer.render(template, context, **kwargs)

 def __init__(self, pd):
     """Creates a new renderer based on a QPaintDevice pd
     """
     self._defpose = Pose() # The pose in the bottom-left corner
     self._zoom = 1 # The zooming factor
     self._zoom_c = False # Whether the scaling is done from center
     Renderer.__init__(self, (pd.width(), pd.height()), pd)

class Game():
    
    def __init__(self):
        SDL_Init(SDL_INIT_VIDEO)

        self.evtMngr = EventManager()
        self.scene = Scene(self.evtMngr)
        self.renderer = Renderer(self.evtMngr, 1000, 800)

        self.evtMngr.attachHandler(E_SDL_EVENT, self.onSDLEvent)

    def run(self):
        self.running = True
        while self.running:
            self.queueSDLEvents()

            self.evtMngr.handleEvents()
            self.scene.update()
            self.renderer.draw(self.scene)

        return 0

    def onSDLEvent(self, eType, e):
        if eType == SDL_QUIT:
            self.running = False
        if eType == SDL_KEYDOWN and e.key.keysym.sym == SDLK_ESCAPE:
            self.running = False

    def queueSDLEvents(self):
        events = sdl2ext.get_events()
        newEvents = dict()
        for event in events:
            self.evtMngr.queueEvent(E_SDL_EVENT, event.type, event)

class Argon(object):
    def __init__(self, width, height):
        self.width  = width
        self.height = height

        self.load = ImageCache([in_module('assets'), os.getcwd(), '.'])
        self.default_font = self.load.font('AnonymousPro_17')

        self.running = False
        self.flags = HWSURFACE | OPENGL | DOUBLEBUF
        self.listeners = {}
        self.frame_latency = []

        pygame.display.set_mode((self.width, self.height), self.flags)
        glEnable(GL_TEXTURE_2D)
        glEnable(GL_BLEND)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

        self.render = Renderer(self, self.default_font)

    def listen(self, fn):
        self.listeners[fn.__name__] = fn
        return fn

    def run(self):
        self.running = True
        while self.running:
            now = time.time()
            self.listeners["on_frame"](now)
            pygame.display.flip()
            self.frame_latency.append(time.time() - now)
            while len(self.frame_latency) > 100:
                self.frame_latency.pop(0)
            for event in pygame.event.get():
                if event.type == QUIT:
                    self.running = False
                event_dispatch(event, self.listeners)

    def clear(self, color):
        r, g, b, a = color
        glClearColor(r/255.0, g/255.0, b/255.0, a/255.0)
        glClear(GL_COLOR_BUFFER_BIT)

    def bind(self):
        glBindFramebuffer(GL_FRAMEBUFFER, 0)

    def unbind(self):
        pass

    def show_performance_log(self):
        latency = self.frame_latency
        font = self.default_font
        if len(latency) > 0:
            avg  = sum(latency) / len(latency)
            high = max(latency) 
            text = "avg=%.2fms high=%.2fms" % (avg * 1000, high * 1000)
            self.render.text((0, self.height - font.height + font.baseline), text)

 def clear_screen(self):
     """Erases the current screen with a white brush"""
     self._painter.save()
     self._painter.resetTransform()
     self.set_pen(0xFFFFFF)
     self.set_brush(0xFFFFFF)
     self.draw_rectangle(0,0,self.size[0],self.size[1])
     self._painter.restore()
     Renderer.clear_screen(self)

class PhysicsGame(Widget):
    def __init__(self, **kwargs):
        super(PhysicsGame, self).__init__(**kwargs)

        self.renderer = Renderer(self)
        self.game_state = RUNNING

        self.renderer.init_physics()
        self.bind(size=self.renderer.update_bounds, pos=self.renderer.update_bounds)

        self.tools = {}
        for t in all_tools:
            self.tools[t.name] = t(self)

        self.current_tool = self.tools["Circle"]
        self.help_scheduled = False

        Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME)
        Clock.schedule_interval(self.step, 1 / 30.0)

    def step(self, dt):
        if self.game_state == RUNNING:
            self.renderer.space.step(1 / 30.0)
        self.renderer.update_objects()

    def on_touch_down(self, touch):
        self.current_tool.on_touch_down(touch)

    def on_touch_up(self, touch):
        self.current_tool.on_touch_up(touch)

    def on_touch_move(self, touch):
        self.current_tool.on_touch_move(touch)

    def set_tool(self, tool_name):
        self.current_tool = self.tools[tool_name]

    def toggle_game_state(self):
        self.game_state = RUNNING if self.game_state == PAUSED else PAUSED

    def game_paused(self):
        return self.game_state

    def get_space(self):
        return self.renderer.space

    def remove_help_text(self, dt, *args):
        self.parent.ids.help_text_label.opacity = 0
        self.help_scheduled = False

    def show_help_text(self, text):
        self.parent.ids.help_text_label.text = text
        self.parent.ids.help_text_label.opacity = 1
        if self.help_scheduled:
            Clock.unschedule(self.remove_help_text)
        self.help_scheduled = True
        Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME)

def main():
    app = Application()
    renderer = Renderer()
    renderer.register_with_app(app)
    #app.request_update_on_draw(Test(renderer).update)

    mainWindow = ui.Window(renderer, 50, 50, 300, 400)
    mainWindow.addWidget(ui.Button, x=20, y=20, width=50, height=60, color=(1, 0, 1, 1), text="Example Text")

    app.run()

 def render(self):
     logger = self.logger
     if logger: logger.renderStart()
     
     Renderer.begin(self)
     for m in self.managers:
         m.render()
     Renderer.end(self)
     
     if logger: logger.renderEnd()

	def __init__(self, name, id):
		self.id = id
		self.name = name

		with file("boards/%s.yaml" % name) as config_file:
			self.config = yaml.load(config_file)

		# Load textures
		self.front = Renderer.load_image("boards/"+self.config['front'])[0]
		self.back = Renderer.load_image("boards/"+self.config['back'])[0]

    def main_menu():
        img = libtcod.image_load('img/menu_background1.png')

        while not libtcod.console_is_window_closed():
            Renderer.render_main_screen(img)

            choice = Renderer.menu('', ['Play a new game', 'Continue current game', 'Quit'], 24, 0)

            if choice == 0:
                Renderer.render_main_screen(img)

                races = race_decoder.decode_all_races()
                race = Renderer.menu('Pick a race', races, 15, 0)
                if race is None:
                    continue

                Renderer.render_main_screen(img)

                jobs = job_decoder.decode_all_jobs()
                job = Renderer.menu('Pick a job', jobs, 15, 0)
                if job is None:
                    continue

                Game.new_game(races[race].lower(), jobs[job].lower())
                Game.run()
            elif choice == 1:
                try:
                    Game.run()
                except:
                    Game.msgbox('\n No saved game to load.\n', 24)
                    continue
            elif choice == 2:
                break

    def get(self):
        """Handle a GET request for the page."""

        if IS_CACHING_ON and self.is_cached:
            with open(self.cached_name) as cachefile:
                page = cachefile.read()
        else:
            renderer = Renderer(view=self)
            page = renderer.render()
            if IS_CACHING_ON:
                self.write_page_to_cache(page)
        print "Content-type:text/html\n", page

def main():
    app = Application()
    renderer = Renderer()
    renderer.register_with_app(app)
    app.request_update_on_draw(Test(renderer).update)

    r = Renderer.Rectangle(1, 2, 20, 30, renderer=renderer)
    try:
        r = Renderer.Rectangle(40, 40, 20, 30)
    except:
        pass

    app.run()

    def next_level():
        Game.message('You take a moment to rest, and recover your strength.', libtcod.light_violet)
        Game.player.fighter.heal(.5)
        Game.player.job.regen_mana(.5)

        Game.message('You descend deeper into the heart of the dungeon...', libtcod.red)
        Game.dungeon_level += 1
        Game.map = Map(Game.MAP_WIDTH, Game.MAP_HEIGHT)
        Game.player.x = Game.map.origin[0]
        Game.player.y = Game.map.origin[1]
        Game.map.add_object(Game.player)

        Renderer.clear_console()
        Game.renderer.map = Game.map

def main():
    win = Window(fullscreen=True, visible=False)
    camera = Camera(win.width, win.height, (0, 0), 100)
    renderer = Renderer()
    maze = Maze()
    maze.create(50, 30, 300)
    keyboard = Keyboard()
    keyboard.key_handlers[key.ESCAPE] = win.close
    keyboard.key_handlers.update(camera.key_handlers)
    clock.schedule(maze.update)
    win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height)
    win.on_key_press = keyboard.on_key_press
    keyboard.print_handlers()
    win.set_visible()
    app.run()

    def set_canvas(self, DC):
        # Reset cached brushes & pens
        self._pens = {}
        self._brushes = {}

        # Set dc
        self._dc = DC
        self._gc = wx.GraphicsContext.Create(self._dc)
        w, h = self._get_canvas_size(DC)

        # Set correct x & y axes directions
        self._gc.Scale(1,-1)
        self._gc.Translate(0, -h)
        self._grid_pen = self._gc.CreatePen(self._dc_grid_pen)
        Renderer.set_canvas(self,DC)

    def run(self, rhoNo=1, phiNo=1, tfNo=1):
        dataset = Dataset(rhoNo, phiNo, tfNo)
        self.numFiles = 0

        renderer = Renderer(self.eye, self.screen)

        numTextures = self.numTextures

        rho = dataset.rho
        phi = dataset.phi
        tf = dataset.tf
        phiPlane = SplinePlane(phi, self.splineInterval, 1e-5)

        boundingBox = phiPlane.createBoundingBox()

        refSplineModel = SplineModel(tf, phiPlane, rho, self.refTolerance)
        voxelModels = np.empty(numTextures, dtype=object)

        for i in range(numTextures):
            texDimSize = self.texDimSizes[i]

            if voxelio.exist(dataset, texDimSize, texDimSize):
                samplingScalars = voxelio.read(dataset, texDimSize, texDimSize)
                print "Read {}x{} texture data from file".format(texDimSize, texDimSize)
            else:
                samplingScalars = refSplineModel.generateScalarMatrix(boundingBox, texDimSize, texDimSize,
                                                                      self.voxelizationTolerance)
                voxelio.write(dataset, samplingScalars)
                print "Wrote {}x{} texture data to file".format(texDimSize, texDimSize)

            scalarTexture = Texture2D(samplingScalars)

            voxelModels[i] = VoxelModel(tf, scalarTexture, boundingBox)

        printflush("Rendering reference... ")
        renderData = RenderData(ModelType.REFERENCE, self.viewRayDelta)
        renderData.renderResult = renderer.render(refSplineModel, self.viewRayDelta)
        self.save(dataset, renderData)
        print "Done!"

        for i, texSize in enumerate(self.texDimSizes):
            delta = self.viewRayDelta

            printflush("Rendering voxelized ({0}x{0})...".format(texSize))
            renderData = RenderData(ModelType.VOXEL, delta=delta, texSize=texSize)
            renderData.renderResult = renderer.render(voxelModels[i], delta)
            self.save(dataset, renderData)
            print "Done!"

    def check_level_up():
        level_up_exp = Game.get_exp_to_level()

        while Game.player.fighter.xp >= level_up_exp:
            Game.player.level += 1
            Game.player.fighter.xp -= level_up_exp
            Game.message('Your battle skills grow stronger! You reached level ' + str(Game.player.level) + '!', libtcod.yellow)

            choice = None
            while choice is None:
                choice = Renderer.menu('Level up! Choose a stat to raise:\n',
                    ['+20 HP, from (' + str(Game.player.fighter.max_hp) + ')',
                    '+10 MP, from (' + str(Game.player.job.max_mp) + ')',
                    '+1 attack, from (' + str(Game.player.fighter.power) + ')',
                    '+1 dexterity, from (' + str(Game.player.fighter.dexterity) + ')'], Renderer.LEVEL_SCREEN_WIDTH)

            if choice == 0:
                Game.player.fighter.base_max_hp += 20
                Game.player.fighter.hp += 20
            elif choice == 1:
                Game.player.job.base_max_mp += 10
                Game.player.job.mp += 10
            elif choice == 2:
                Game.player.fighter.base_power += 1
            elif choice == 3:
                Game.player.fighter.base_dexterity += 1
            Game.renderer.render_all()

class ProcessHandler(webapp.RequestHandler):
  def __init__(self):
    self.template_renderer = Renderer('process.html')
    self.user_handler = UserHandler()
    self.user_obj = None
  
  def setUser(self):
    self.user_obj = self.user_handler.handleUser()

  def get(self, step):
    self.setUser()
    #self.response.out.write('in step %s' % step)
    if step == PROCESS_STEP_1_START:
      return self.ProcessStep1()
    elif step == PROCESS_STEP_2_EXECUTE:
      return self.ProcessStep2()
    else:
      pass
    
  def ProcessStep1(self):
    self.template_renderer.template_values['process_step'] = '1'
    self.template_renderer.template_values['next_step'] = PROCESS_STEP_2_EXECUTE
    self.render()
    
  def ProcessStep2(self):
    self.template_renderer.template_values['process_step'] = '2'
    self.render()
    
  def render(self):
    self.template_renderer.template_values['token'] = self.user_obj.spreadsheet_session_token
    self.response.out.write(self.template_renderer.render())