Working with Hatch Patterns in PS file | Java

Add Hatch Pattern in PS Document

A hatch pattern is a texture tiling pattern usually represented by a small 2-color (usually black & white) simple image. The main content of these small images is various hatches.

The Java platform doesn’t have a separate class for painting shapes and text with hatches. However, the Aspose.Page for Java library offers the com.aspose.eps.HatchPaintLibrary class that gives a possibility to create java.awt.TexturePaint filled with hatches defined by one of 55 styles offered by com.aspose.eps.HatchStyle.

In order to paint graphics objects with a hatch pattern in the Aspose.Page for Java library, it is necessary to create a hatch java.awt.TexturePaint with an assigned hatch style, pass it into setPaint() or one of the fillText() or fillAndStrokeText() methods that accept java.awt.Paint as a parameter.

In order to outline graphics objects with a hatch pattern in the Aspose.Page for Java library, one should set a hatch pattern as the current paint in PsDocument, create a new java.awt.BasicStroke, and pass it to setStroke() or one of the outlineText() or fillAndStrokeText() methods that accept java.awt.Stroke as a parameter.

In the example below we demonstrate, firstly, how to fill a shape with a hatch pattern, then all variety of hatch styles in Java, and, finally, how to fill and outline a text with a hatch pattern.

An algorithm for painting graphics objects with a hatch pattern in a new PS document includes the following steps:

1. Create an output stream for the resulting PS file.
2. Create PsSaveOptions.
3. Create PsDocument with the already created output stream and save options.
4. Create the shape or font depending on what object we are going to fill or outline.
5. Create an object of java.awt.TexturePaint with a desired style using com.aspose.eps.HatchPaintLibrary.
6. Set the hatch paint as the current paint in PsDocument.
7. Fill the shape with the current paint or fill a text. If we use one of the methods for filling a text that accepts java.awt.Paint as a parameter, the previous point can be ignored.
8. Close the page.
9. Save the document.

If we need stroking (outlining) graphics objects with a hatch pattern, instead of the last 4 points, the following will be used:

6. Set the hatch paint as the current paint in PsDocument.
7. Create a java.awt.BasicStroke object.
8. Set this stroke as the current stroke in PsDocument.
9. Outline the shape with the current paint and stroke, or outline the text. If we use one of the methods for outlining the text that accepts java.awt.Stroke as a parameter, the previous point can be ignored.
10. Close the page.
11. Save the document.

  // Demonstrates all embedded hatch patterns that can be used to paint or outline shapes or text in PS document.

  String outputFileName = "AddHatchPattern_outPS.ps";

  //Create save options with A4 size
  PsSaveOptions options = new PsSaveOptions();

  // Create new 1-paged PS Document
  PsDocument document = new PsDocument(getOutputDir() + outputFileName, options, false);

  int x0 = 20;
  int y0 = 100;
  int squareSide = 32;
  int width = 500;
  int sumX = 0;

//Restore graphics state
  document.writeGraphicsSave();

  //Translate to initial point
  document.translate(x0, y0);
  
  //Create a square for every pattern
  Rectangle2D.Float square = new Rectangle2D.Float(0, 0, squareSide, squareSide);
  
  //Create pen for outlining pattern square
  BasicStroke stroke = new BasicStroke(2);
  
  HatchStyle [] hatchStyles = HatchStyle.values();
  
  //For every hatch pattern style 
  for (int i = 0; i < hatchStyles.length; i++) {            
  	//Create a hatch texture pattern by hatch style, foreground and background colors
  	TexturePaint paint = HatchPaintLibrary.getHatchTexturePaint(hatchStyles[i], Color.BLACK, Color.WHITE);
  	//Set paint with the current hatch pattern
      document.setPaint(paint);

      //Calculate a displacement in order to don't go beyond the page bounds
      int x = squareSide;
      int y = 0;
      if (sumX >= width) {
          x = -(sumX - squareSide);
          y += squareSide;
      }

      //Translate current graphics state
      document.translate(x, y);
      //Fill pattern square
      document.fill(square);

      //Set current paint
      document.setPaint(Color.BLACK);
      //Set current stroke
      document.setStroke(stroke);
      //Draw square outline
      document.draw(square);

      //Calculate distance from X0
      if (sumX >= width)
          sumX = squareSide;
      else
          sumX += x;
  }
  
  //Restore graphics state
  document.writeGraphicsRestore();
  
  //Fill a text with the hatch pattern
  TexturePaint paint = HatchPaintLibrary.getHatchTexturePaint(HatchStyle.DiagonalCross, Color.RED, Color.YELLOW);
  Font font = new Font("Arial", Font.BOLD, 96);
  document.fillAndStrokeText("ABC", font, 200, 320, paint, Color.BLACK, stroke);

  //Outline the text with the hatch pattern
  paint = HatchPaintLibrary.getHatchTexturePaint(HatchStyle.Percent70, Color.BLUE, Color.WHITE);
  document.outlineText("ABC", font, 200, 420, paint, new BasicStroke(5));

  //Close current page
  document.closePage();

  //Save the document
  document.save();

See working with a hatch pattern in PS document in .NET.

The result of running this code appears as follows:

You can download examples and data files from GitHub.