Paint all the appropriate indicators for our scene objects.
494767
protected void paintIndicators (Graphics2D gfx, Rectangle clip)
    {
        // make sure the indicators are ready
        if (!_indicatorsLaidOut) {
            for (Map.Entry<SceneObject, SceneObjectIndicator> entry : _indicators.entrySet()) {
                SceneObjectIndicator indic = entry.getValue();
                if (!indic.isLaidOut()) {
                    indic.layout(gfx, entry.getKey(), _vbounds);
                    dirtyIndicator(indic);
                }
            }
            _indicatorsLaidOut = true;
        }

        if (checkShowFlag(SHOW_TIPS)) {
            // show all the indicators
            for (SceneObjectIndicator indic : _indicators.values()) {
                paintIndicator(gfx, clip, indic);
            }

        } else {
            // show maybe one indicator
            SceneObjectIndicator indic = _indicators.get(_hobject);
            if (indic != null) {
                paintIndicator(gfx, clip, indic);
            }
        }
    }
541925
function(marker) {
        this.markers.push(marker);

        if (this.opacity < 1) {
            marker.setOpacity(this.opacity);
        }

        if (this.map && this.map.getExtent()) {
            marker.map = this.map;
            this.drawMarker(marker);
        }
    }
591411
private void paintEnabled(Graphics2D g, JComponent c, int width, int height) {
        paintMenu(g, c, width, height, enabled);
    }
1059222
def draw(self, milliseconds, surface):
        """"""
        surface.blit(self.image, self.coords, self.source, special_flags=0)
786662
@Override
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		getPaintingRegion().update();
		paintAxes(g);
		paintTicks(g);
		paintValues(g, paintLines);
	}
1024864
public void paint (Graphics2D gfx)
    {
        paint(gfx, bounds.x, bounds.y, _background, null);
    }
580985
public void paintIcon (Component c, Graphics g, int x, int y)
    {
        Graphics2D gfx = (Graphics2D) g;
        AffineTransform otrans = gfx.getTransform();
        RenderingHints ohints = gfx.getRenderingHints();

        gfx.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
            RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        gfx.scale(_scale, _scale);
        _icon.paintIcon(c, g, x, y);

        gfx.setTransform(otrans);
        gfx.setRenderingHints(ohints);
    }
32522
function () {
            each(this.series, function (serie) {
                serie.translate();
                if (serie.setTooltipPoints) {
                    serie.setTooltipPoints();
                }
                serie.render();
            });
        }
901198
def paintMilestone( self, painter ):
        
        # generate the rect
        rect    = self.rect()
        
        padding = self.padding()
        gantt   = self.scene().ganttWidget()
        cell_w  = gantt.cellWidth()
        cell_h  = gantt.cellHeight()
        
        x       = rect.width() - cell_w
        y       = self.padding()
        w       = cell_w
        h       = rect.height() - padding - 2
        
        # grab the color options
        color       = self.color()
        alt_color   = self.alternateColor()
        
        if ( self.isSelected() ):
            color       = self.highlightColor()
            alt_color   = self.alternateHighlightColor()
        
        # create the background brush
        gradient = QLinearGradient()
        gradient.setStart(0, 0)
        gradient.setFinalStop(0, h)
        
        gradient.setColorAt(0,   color)
        gradient.setColorAt(0.8, alt_color)
        gradient.setColorAt(1,   color)
        
        painter.setPen(self.borderColor())
        painter.setBrush(QBrush(gradient))
        
        pen = painter.pen()
        pen.setWidthF(0.5)
        painter.setPen(pen)
        painter.setRenderHint( painter.Antialiasing )
        
        path = QPainterPath()
        path.moveTo(x - cell_w / 3.0, y + h / 2.0)
        path.lineTo(x, y)
        path.lineTo(x + cell_w / 3.0, y + h / 2.0)
        path.lineTo(x, y + h)
        path.lineTo(x - cell_w / 3.0, y + h / 2.0)
        
        painter.drawPath(path)
1310643
protected void paint (Graphics2D gfx, int x, int y, Color background, Object cliData)
    {
        // turn on anti-aliasing (for our sausage lines)
        Object oalias = SwingUtil.activateAntiAliasing(gfx);

        // draw the base sausage
        gfx.setColor(background);
        drawBase(gfx, x, y);

        // render our icon if we've got one
        drawIcon(gfx, x, y, cliData);

        drawLabel(gfx, x, y);
        drawBorder(gfx, x, y);

        drawExtras(gfx, x, y, cliData);

        // restore original hints
        SwingUtil.restoreAntiAliasing(gfx, oalias);
    }
870303
def paintEvent(self, event):
        """"""
        super(FigureCanvas, self).paintEvent(event)
        # Prepare the rect on which the image is going to be painted :
        fw = self.frameWidth()
        rect = QRect(0 + fw, 0 + fw,
                     self.size().width() - 2 * fw,
                     self.size().height() - 2 * fw)

        if self.fig is None or self._blink_flag:
            return

        # Check/update the qpixmap buffer :
        qpix2paint = None
        for qpix in self._qpix_buffer:
            if qpix.size().width() == rect.width():
                qpix2paint = qpix
                break
        else:
            if self.fmt in ['image/png', 'image/jpeg']:
                qpix2paint = self._qpix_orig.scaledToWidth(
                    rect.width(), mode=Qt.SmoothTransformation)
            elif self.fmt == 'image/svg+xml':
                qpix2paint = QPixmap(svg_to_image(self.fig, rect.size()))
            self._qpix_buffer.append(qpix2paint)

        if qpix2paint is not None:
            # Paint the image on the widget :
            qp = QPainter()
            qp.begin(self)
            qp.drawPixmap(rect, qpix2paint)
            qp.end()
1276502
public void paintAndClear (Graphics2D gfx)
    {
        int icount = _items.size();
        for (int ii = 0; ii < icount; ii++) {
            DirtyItem item = _items.get(ii);
            item.paint(gfx);
            item.clear();
            _freelist.add(item);
        }
        _items.clear();
    }
866265
function(){
		var paths = this.components;
		for(var i=0;i<paths.length;i++){
			paths[i].color = this.puzzle.painter.getNewLineColor();
		}
	}
602006
public void paintPerf (Graphics2D gfx)
    {
        if (_perfRect != null && FrameManager._perfDebug.getValue()) {
            gfx.setClip(null);
            _perfLabel.render(gfx, _perfRect.x, _perfRect.y);
        }
    }
334713
function(components){
		var clist_all = new this.klass.CellList();
		for(var i=0;i<components.length;i++){
			clist_all.extend(components[i].getnodeobjs());
		}
		this.puzzle.painter.repaintBlocks(clist_all);
	}
1228486
protected void paintTicks(Graphics g) {
		if(isAxisPaintedfor(ValueDimension.X))
			paintTicks(g, ValueDimension.X);
		if(isAxisPaintedfor(ValueDimension.Y))
			paintTicks(g, ValueDimension.Y);
	}
1156029
def paintEvent(self, event):
        
        pixmap = self.currentPixmap()
        rect   = self.currentPixmapRect()
        
        with XPainter(self) as painter:
            painter.drawPixmap(rect.x(), rect.y(), pixmap)