Draw all the sprites in the system using their renderers.

        This method is convenient to call from you Pyglet window's
        on_draw handler to redraw particles when needed.
439533
def draw(self):
        
        glPushAttrib(GL_ALL_ATTRIB_BITS)
        self.draw_score()
        for sprite in self:
            sprite.draw()
        glPopAttrib()
803026
def draw(self):
        """"""
        # update or particle positions by calling the OpenCL kernel
        # self.cle.execute(10)
        OpenGL.GL.glFlush()

        OpenGL.GL.glClear(
            OpenGL.GL.GL_COLOR_BUFFER_BIT | OpenGL.GL.GL_DEPTH_BUFFER_BIT
        )
        if self.white == -1:
            OpenGL.GL.glClearColor(1, 1, 1, 1)
        else:
            OpenGL.GL.glClearColor(0, 0, 0, 0)
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_MODELVIEW)
        OpenGL.GL.glLoadIdentity()

        # handle mouse transformations
        OpenGL.GL.glTranslatef(
            self.initrans.x, self.initrans.y, self.initrans.z
        )
        OpenGL.GL.glRotatef(self.rotate.x, 1, 0, 0)
        OpenGL.GL.glRotatef(
            self.rotate.y, 0, 1, 0
        )  # we switched around the axis so make this rotate_z
        OpenGL.GL.glTranslatef(
            self.translate.x, self.translate.y, self.translate.z
        )

        # render the matrix
        self.render_image()
        # render the particles
        self.render()

        # draw the x, y and z axis as lines
        glutil.draw_axes()
        # enable 2d display #
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_PROJECTION)
        OpenGL.GL.glPushMatrix()
        OpenGL.GL.glLoadIdentity()
        OpenGL.GL.glOrtho(0.0, self.width, self.height, 0.0, -1.0, 10.0)
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_MODELVIEW)
        # glPushMatrix()        ----Not sure if I need this
        OpenGL.GL.glLoadIdentity()
        OpenGL.GL.glDisable(OpenGL.GL.GL_CULL_FACE)

        OpenGL.GL.glClear(OpenGL.GL.GL_DEPTH_BUFFER_BIT)

        # glBegin(GL_LINES)
        # glColor3f(0.0, 1.0, 0.0)
        # glVertex2f(0.0, 0.0)
        # glVertex2f(100.0, 0.0)
        # glVertex2f(100.0, 100.0)
        # glVertex2f(0.0, 100.0)
        # glEnd()

        if self.white == 1:
            self.glut_print(
                10,
                15,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_cycle,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                30,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_temp,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                45,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_id_frag,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                60,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_likelihood,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                75,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_n_contigs,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                90,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_dist,
                0.0,
                1.0,
                0.0,
                1.0,
            )
        else:
            self.glut_print(
                10,
                15,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_cycle,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                30,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_temp,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                45,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_id_frag,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                60,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_likelihood,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                75,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_n_contigs,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                90,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_dist,
                0.0,
                0.0,
                0.0,
                1.0,
            )

        # self.glut_print( 10 , 15 , GLUT_BITMAP_9_BY_15 , self.str_curr_cycle
        # , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 10 , 30 ,
        # GLUT_BITMAP_9_BY_15 , self.str_curr_temp , 1.0 , 1.0 , 1.0 , 1.0)
        # self.glut_print( 10 , 45 , GLUT_BITMAP_9_BY_15 ,
        # self.str_curr_id_frag , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 10 ,
        # 60 , GLUT_BITMAP_9_BY_15 , self.str_likelihood , 1.0 , 1.0 , 1.0 ,
        # 1.0) self.glut_print( 10.1 , 60.1 , GLUT_BITMAP_9_BY_15 ,
        # self.str_likelihood , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 9.9 ,
        # 59.9, GLUT_BITMAP_9_BY_15 , self.str_likelihood , 1.0 , 1.0 , 1.0 ,
        # 1.0) self.glut_print( 10 , 75 , GLUT_BITMAP_9_BY_15 ,
        # self.str_n_contigs , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 10 , 90
        # , GLUT_BITMAP_9_BY_15 , self.str_curr_dist , 1.0 , 1.0 , 1.0 , 1.0)

        # self.glut_print( 10 , 15 , GLUT_BITMAP_9_BY_15 , self.str_curr_cycle
        # , 0.0 , 0.0 , 0.0 , 1.0) self.glut_print( 10 , 30 ,
        # GLUT_BITMAP_9_BY_15 , self.str_curr_temp , 0.0 , 0.0 , 0.0 , 1.0)
        # self.glut_print( 10 , 45 , GLUT_BITMAP_9_BY_15 ,
        # self.str_curr_id_frag , 0.0 , 0.0 , 0.0 , 1.0) self.glut_print( 10 ,
        # 60 , GLUT_BITMAP_9_BY_15 , self.str_likelihood , 0.0 , 0.0 , 0.0 ,
        # 1.0) self.glut_print( 10 , 75 , GLUT_BITMAP_9_BY_15 ,
        # self.str_n_contigs , 0.0 , 0.0 , 0.0 , 1.0) self.glut_print( 10 , 90
        # , GLUT_BITMAP_9_BY_15 , self.str_curr_dist , 0.0 , 0.0 , 0.0 , 1.0)

        # Making sure we can render 3d again
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_PROJECTION)
        OpenGL.GL.glPopMatrix()
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_MODELVIEW)
        # glPopMatrix()##        ----and this?

        #############
        OpenGL.GLUT.glutSwapBuffers()
1308367
def Draw(self, *args, **kwargs):
        
        self.reset()
        output = None
        while self._rollover():
            if output is None:
                # Make our own copy of the drawn histogram
                output = self._tree.Draw(*args, **kwargs)
                if output is not None:
                    output = output.Clone()
                    # Make it memory resident (histograms)
                    if hasattr(output, 'SetDirectory'):
                        output.SetDirectory(0)
            else:
                newoutput = self._tree.Draw(*args, **kwargs)
                if newoutput is not None:
                    if isinstance(output, _GraphBase):
                        output.Append(newoutput)
                    else:  # histogram
                        output += newoutput
        return output
297944
def draw(self):
        """"""

        cell_background_renderer = GridCellBackgroundCairoRenderer(
            self.context,
            self.code_array,
            self.key,
            self.rect,
            self.view_frozen)

        cell_content_renderer = GridCellContentCairoRenderer(
            self.context,
            self.code_array,
            self.key,
            self.rect,
            self.spell_check)

        cell_border_renderer = GridCellBorderCairoRenderer(
            self.context,
            self.code_array,
            self.key,
            self.rect)

        cell_background_renderer.draw()
        cell_content_renderer.draw()
        cell_border_renderer.draw()
673220
def draw(self, milliseconds, render_surface):
        """"""
        if self.is_visible:
            if not (self.__scale[0] == 0 or self.__scale[1] == 0):
                if self.image is not None:
                    # Create our rectangle to describe our sprite.
                    tmpRect = pygame.Rect(self.coords.X - self.__origin.X,
                                          self.coords.Y - self.__origin.Y,
                                          self.image.get_width(),
                                          self.image.get_height())
                    # Apply tinting to the sprite.
                    # tintedSurface = self.image.copy()
                    # self.image.fill(self.tint_color, special_flags = pygame.BLEND_RGB_MULT)
                    render_surface.blit(self.image, tmpRect, self.source, special_flags=0)
524376
function draw(renderer, container) {
         var translateX = this.pos.x + this.offset.x;
         var translateY = this.pos.y + this.offset.y; // translate the world coordinates by default to screen coordinates

         container.currentTransform.translate(-translateX, -translateY); // clip to camera bounds

         renderer.clipRect(0, 0, this.width, this.height);
         this.preDraw(renderer);
         container.preDraw(renderer); // draw all objects,
         // specifying the viewport as the rectangle area to redraw

         container.draw(renderer, this); // draw the viewport/camera effects

         this.drawFX(renderer);
         container.postDraw(renderer);
         this.postDraw(renderer); // translate the world coordinates by default to screen coordinates

         container.currentTransform.translate(translateX, translateY);
       }
1342967
def draw(self):
        '''
        
        '''
        if self.__conditional_flag is True:
            return np.concatenate((self.__create_samples(), self.__create_samples()), axis=1)
        else:
            return self.__create_samples()
231396
def render(self):
        '''
        
        '''
        # Render each layer and update data frame with new content for each
        # surface.
        surface_names = ('background', 'shapes', 'connections', 'routes',
                         'channel_labels', 'static_electrode_state_shapes',
                         'dynamic_electrode_state_shapes', 'registration')
        for k in surface_names:
            self.set_surface(k, getattr(self, 'render_' + k)())
        self.emit('surfaces-reset', self.df_surfaces)
        self.cairo_surface = flatten_surfaces(self.df_surfaces)
949428
public void redraw() {
		groups.clear();
		mapWidget.getVectorContext().deleteGroup(editingService.getGeometry());
		draw(editingService.getGeometry());
	}
1291393
function draw(renderer) {
         var color = renderer.getColor();
         var height = renderer.getHeight(); // draw the progress bar

         renderer.setColor("black");
         renderer.fillRect(this.pos.x, height / 2, this.width, this.height / 2);
         renderer.setColor("#55aa00");
         renderer.fillRect(this.pos.x, height / 2, this.progress, this.height / 2);
         renderer.setColor(color);
       }
26704
protected void fireDrawingStart() {
		final ListenerCollection<EventListener> list = this.listeners;
		if (list != null) {
			for (final DrawingListener listener : list.getListeners(DrawingListener.class)) {
				listener.onDrawingStart();
			}
		}
	}
327803
def draw(self, viewer):
        
        cache = self.get_cache(viewer)

        if not cache.drawn:
            cache.drawn = True
            viewer.redraw(whence=2)

        cpoints = self.get_cpoints(viewer)
        cr = viewer.renderer.setup_cr(self)

        # draw optional border
        if self.linewidth > 0:
            cr.draw_polygon(cpoints)

        if self.showcap:
            self.draw_caps(cr, self.cap, cpoints)
1133775
def render_particles(self):
        
        for strip_pos in range(self._start, self._end + 1):

            blended = COLORS.black

            # Render visible emitters
            if self.has_e_colors:
                for (e_pos, e_dir, e_vel, e_range,
                     e_color, e_pal) in self.emitters:
                    if e_color is not None:
                        vis = self.visibility(strip_pos, e_pos)
                        if vis > 0:
                            blended = color_blend(
                                blended,
                                color_scale(e_color, int(vis * 255)))

            # Render visible particles
            for vel, pos, stl, color, bright in self.particles:
                vis = self.visibility(strip_pos, pos)
                if vis > 0 and bright > 0:
                    blended = color_blend(
                        blended,
                        color_scale(color, int(vis * bright)))

            # Add background if showing
            if (blended == COLORS.black):
                blended = self.bgcolor

            self.color_list[strip_pos] = blended
175246
public void redraw() {
		shapes.clear();
		if (container != null) {
			container.setTranslation(0, 0);
			container.clear();
			try {
				tentativeMoveLine = new Path(-5, -5);
				tentativeMoveLine.lineTo(-5, -5);
				ShapeStyle style = styleProvider.getEdgeTentativeMoveStyle();
				GeomajasImpl.getInstance().getGfxUtil().applyStyle(tentativeMoveLine, style);
				container.add(tentativeMoveLine);
				draw();
			} catch (GeometryIndexNotFoundException e) {
				// Happens when creating new geometries...can't render points that don't exist yet.
			}
		}
	}
364171
void draw(GLShader shader, InternalTransform xform, int tint,
            float dx, float dy, float dw, float dh) {
    draw(shader, xform, tint, dx, dy, dw, dh,
         0, 0, (repeatX ? dw : width()), (repeatY ? dh : height()));
  }
591908
@Override
    public void redraw() {
        if (!isDrawn()) {
            draw();
        } else {
            try {
                beforeLoad();
                beforeDataSetLookup();
                dataSetHandler.lookupDataSet(new DataSetReadyCallback() {
                    public void callback(DataSet result) {
                        try {
                            dataSet = result;
                            afterDataSetLookup(result);
                            updateVisualization();

                            // Redraw done
                            afterRedraw();
                        } catch (Exception e) {
                            // Give feedback on any initialization error
                            showError(new ClientRuntimeError(e));
                        }
                    }
                    public void notFound() {
                        String uuid = displayerSettings.getDataSetLookup().getDataSetUUID();
                        getView().errorDataSetNotFound(uuid);
                        handleError("Data set not found: " + uuid);
                    }

                    @Override
                    public boolean onError(final ClientRuntimeError error) {
                        showError(error);
                        return false;
                    }
                });
            } catch (Exception e) {
                showError(new ClientRuntimeError(e));
            }
        }
    }
162716
def draw(self):
        
        n_rows, n_cols = self.term.stdscr.getmaxyx()
        if n_rows < self.term.MIN_HEIGHT or n_cols < self.term.MIN_WIDTH:
            # TODO: Will crash when you try to navigate if the terminal is too
            # small at startup because self._subwindows will never be populated
            return

        self._row = 0
        self._draw_header()
        self._draw_banner()
        self._draw_content()
        self._draw_footer()
        self.term.clear_screen()
        self.term.stdscr.refresh()