Paints multiple copies of the supplied image using the supplied graphics context such that
the requested height is filled with the image.
435332
public static void tileImageDown (Graphics2D gfx, Mirage image, int x, int y, int height)
    {
        tileImage(gfx, image, x, y, image.getWidth(), height);
    }
1355779
public void paint (Graphics2D gfx, int x, int y)
    {
        // Paint everyone.
        for (Mirage m : _mirages) {
            m.paint(gfx, x, y);
        }
    }
59224
protected void paintTicks(Graphics g, ValueDimension dim) {
		for(int i=0; i<getTickInfo(dim).getTickNumber(); i++) {
			if(i % getTickInfo(dim).getTickMultiplicator() != 0)
				paintTick(g, dim, getTickInfo(dim).getFirstTick()+i*getTickInfo(dim).getMinorTickSpacing(), getTickInfo(dim).getMinorTickLength());
			else paintTick(g, dim, getTickInfo(dim).getFirstTick()+i*getTickInfo(dim).getMinorTickSpacing(), getTickInfo(dim).getMajorTickLength());
		}
	}
747385
def drawOverlay(self, painter, option, rect, icon):
        
        if icon and not icon.isNull():
            painter.drawPixmap(rect, icon.pixmap(rect.width(), rect.height()))
503294
public void drawImage(final Context2D context)
    {
        if (isLoaded())
        {
            doUpdateCheck();

            if (context.isSelection())
            {
                if (ImageSelectionMode.SELECT_BOUNDS == m_image.getImageSelectionMode())
                {
                    context.setFillColor(m_image.getColorKey());

                    context.beginPath();

                    context.rect(0, 0, m_dest_wide, m_dest_high);

                    context.fill();

                    context.closePath();
                }
                else
                {
                    context.drawImage(m_selectImage.getElement(), 0, 0);
                }
            }
            else
            {
                if (m_fastout)
                {
                    context.drawImage(m_jsimg, m_clip_xpos, m_clip_ypos, m_clip_wide, m_clip_high, 0, 0, m_dest_wide, m_dest_high);
                }
                else
                {
                    context.drawImage(m_filterImage.getElement(), 0, 0);
                }
            }
        }
    }
1333679
public static BufferedImage joinImages(List<BufferedImage> images, int lines, int height, int minHeight, boolean scale) {

      // Array of input images.
      List<BufferedImage> input = new ArrayList<BufferedImage>();

      int actualHeight = height;

      // if not scale, start from 1, so will use the max height of images, not more than that.
      if (!scale) {
        actualHeight = 1;
      }

      for (BufferedImage imageToJoin : images) {
        try {
          BufferedImage img = MyImageUtils.trim(imageToJoin);

          if (scale) {
            actualHeight = Integer.min(actualHeight, img.getHeight());
          } else {
            actualHeight = Integer.max(actualHeight, img.getHeight());
          }
          input.add(img);

        } catch (Exception x) {
          x.printStackTrace();
        }
      }

      // minimum height for the posts is 480
      if (scale && actualHeight < minHeight 
          && input.size() > 0) {
        actualHeight = minHeight;
      }

      int totalWidth = 0;
      List<BufferedImage> fixedInput = new ArrayList<BufferedImage>();
      for (BufferedImage img : input) {
        BufferedImage newImg = img;
        if (scale && img.getHeight() > actualHeight) {
          newImg = MyImageUtils.resizeToHeight(img, actualHeight);
        }

        fixedInput.add(newImg);

        totalWidth += newImg.getWidth();
      }

      // Create the output image and fill with white.
      
      BufferedImage output = getWhiteImage(actualHeight * lines, totalWidth / lines);
      drawImages(lines, scale, input, actualHeight, output.getGraphics());
      
      return output;
  }
890443
function recolorImageWithCanvasContext(context, img, colorFunc) {
  if (!defined(context)) {
    throw new DeveloperError("No context for image recoloring.");
  }

  // Copy the image contents to the canvas
  context.clearRect(0, 0, context.canvas.width, context.canvas.height);
  context.drawImage(img, 0, 0);
  var image = context.getImageData(
    0,
    0,
    context.canvas.width,
    context.canvas.height
  );
  image = ImageryProviderHooks.recolorImage(image, colorFunc);
  return image;
}
1223731
private void paintBackgroundHover(Graphics2D g, JComponent c, int width, int height) {
        paintBackground(g, c, width, height, hover);
    }
1313184
@Override
    protected void paintComponent(Graphics g) {
        final Graphics2D G2 = (Graphics2D) g.create();

        G2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        G2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        G2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
        G2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

        // Translate the coordinate system related to insets
        G2.translate(getFramelessOffset().getX(), getFramelessOffset().getY());

        // Draw combined background image
        G2.drawImage(bImage, 0, 0, null);

        // Draw the symbol image
        if (on) {
            G2.drawImage(symbolOnImage, 0, 0, null);
        } else {
            G2.drawImage(symbolOffImage, 0, 0, null);
        }

        // Draw combined foreground image
        G2.drawImage(fImage, 0, 0, null);

        if (!isEnabled()) {
            G2.drawImage(disabledImage, 0, 0, null);
        }

        // Translate the coordinate system back to original
        G2.translate(-getInnerBounds().x, -getInnerBounds().y);

        G2.dispose();
    }
1068127
private void paintRestorePressed(Graphics2D g, JComponent c, int width, int height) {
        restorePainter.paintPressed(g, c, width, height);
    }
1152037
public static void paintCheckedBackground(Component c, Graphics g, int x, int y, int width, int height) {
		if ( backgroundImage == null ) {
			backgroundImage = new BufferedImage( 64, 64, BufferedImage.TYPE_INT_ARGB );
			Graphics bg = backgroundImage.createGraphics();
			for ( int by = 0; by < 64; by += 8 ) {
				for ( int bx = 0; bx < 64; bx += 8 ) {
					bg.setColor( ((bx^by) & 8) != 0 ? Color.lightGray : Color.white );
					bg.fillRect( bx, by, 8, 8 );
				}
			}
			bg.dispose();
		}

		if ( backgroundImage != null ) {
			Shape saveClip = g.getClip();
			Rectangle r = g.getClipBounds();
			if (r == null)
				r = new Rectangle(c.getSize());
			r = r.intersection(new Rectangle(x, y, width, height));
			g.setClip(r);
			int w = backgroundImage.getWidth();
			int h = backgroundImage.getHeight();
			if (w != -1 && h != -1) {
				int x1 = (r.x / w) * w;
				int y1 = (r.y / h) * h;
				int x2 = ((r.x + r.width + w - 1) / w) * w;
				int y2 = ((r.y + r.height + h - 1) / h) * h;
				for (y = y1; y < y2; y += h)
					for (x = x1; x < x2; x += w)
						g.drawImage(backgroundImage, x, y, c);
			}
			g.setClip(saveClip);
		}
	}
1090579
public void paintFrame (Graphics2D g, int index, int x, int y) {
        _images[index].paint(g, x, y);
    }
838737
private void paintContinuous(Graphics2D g, JComponent c, int width, int height) {
        boolean useToolBarColors = isInToolBar(c);
        Shape   s;

        if (isFocused) {
            s = shapeGenerator.createSliderThumbContinuous(0, 1, width);
            g.setPaint(getFocusPaint(s, FocusType.OUTER_FOCUS, useToolBarColors));
            g.fill(s);
            s = shapeGenerator.createSliderThumbContinuous(1, 2, width - 2);
            g.setPaint(getFocusPaint(s, FocusType.INNER_FOCUS, useToolBarColors));
            g.fill(s);
        }

        s = shapeGenerator.createSliderThumbContinuous(2, 3, width - 4);

        if (!isFocused) {
            dropShadow.fill(g, s);
        }

        g.setPaint(getCommonBorderPaint(s, type));
        g.fill(s);

        s = shapeGenerator.createSliderThumbContinuous(3, 4, width - 6);
        g.setPaint(getCommonInteriorPaint(s, type));
        g.fill(s);
    }
334786
public void paintEnabled(Graphics2D g, JComponent c, int width, int height) {
        paint(g, c, width, height, enabledBorder, enabledCorner, enabledInterior);
    }
814444
private void paintCheckIconEnabled(Graphics2D g, int width, int height) {
        g.setPaint(iconEnabled);
        g.drawRoundRect(0, 1, width-1, height-2, 4, 4);
    }
103404
private void drawEnabledGraphic(Graphics2D g, int width, int height) {
        Shape s = shapeGenerator.createTabCloseIcon(2, 2, width - 4, height - 4);

        g.setPaint(createGraphicInnerShadowGradient(s));
        g.fill(s);
    }
519943
public void paintHover(Graphics2D g, JComponent c, int width, int height) {
        paint(g, c, width, height, hoverBorder, hoverCorner, hoverInterior);
    }