Working with Hatch Patterns in PostScript | C++

Add Hatch Pattern in PS Document

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

For painting by hatches, the C++ platform has a separate class, derived from System.Drawing.Brush, System.Drawing.HatchBrush. Its difference from System.Drawing.TextureBrush is that it has named predefined styles defining what image to use for tiling. C++ platform offers 53 hatch styles and all 52 styles can be used for filling or stroking (outlining) in PsDocument.

In order to paint graphics objects with a hatch pattern in Aspose.Page for C++ library it is enough simply to pass System.Drawing.HatchBrush to SetPaint() or one of the FillText() or FillAndStrokeText() methods that accept System.Drawing.Brush as a parameter.

In order to outline graphics objects with a hatch pattern in Aspose.Page for C++ library someone should create new System.Drawing.Pen with System.Drawing.HacthBrush and pass it to SetStroke() or one of the OutlineText() or FillAndStrokeText() methods that accept System.Drawing.Pen 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 C++, 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 necessary graphics path or font in dependence on what object we are going to fill or outline.
5. Create an object of System.Drawing.HatchBrush with wishful style.
6. Set the hatch brush as current paint in PsDocument
7. Fill the graphics path with current paint or fill a text. If we use one of the methods for filling a text that accepts System.Drawing.Brush 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 following will be:

6. Create System.Drawing.Pen object with the hatch brush.

7. Set this pen as current stroke in PsDocument.

8. Outline the graphics path with current stroke or outline the text. If we use one of the methods for outlining the text that accepts System.Drawing.Pen as a parameter, previous point can be ignored.

9. Close the page.

10. Save the document.
    

    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithHatches();
    
    //Create output stream for PostScript document
    {
        System::SharedPtr<System::IO::Stream> outPsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"AddHatchPattern_outPS.ps", System::IO::FileMode::Create);
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_0({ outPsStream});
        // ------------------------------------------
        
        try
        {
            //Create save options with A4 size
            System::SharedPtr<PsSaveOptions> options = System::MakeObject<PsSaveOptions>();
            
            // Create new 1-paged PS Document
            System::SharedPtr<PsDocument> document = System::MakeObject<PsDocument>(outPsStream, options, false);
            
            int32_t x0 = 20;
            int32_t y0 = 100;
            int32_t squareSide = 32;
            int32_t width = 500;
            int32_t sumX = 0;
            
            //Restore graphics state
            document->WriteGraphicsSave();
            
            //Translate to initial point
            document->Translate(static_cast<float>(x0), static_cast<float>(y0));
            
            //Create rectngle path for every pattern square
            System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
            path->AddRectangle(System::Drawing::RectangleF(0.0f, 0.0f, static_cast<float>(squareSide), static_cast<float>(squareSide)));
            
            //Create pen for outlining pattern square
            System::SharedPtr<System::Drawing::Pen> pen = System::MakeObject<System::Drawing::Pen>(System::Drawing::Color::get_Black(), 2.0f);
            
            //For every hatch pattern style 
            for (System::Drawing::Drawing2D::HatchStyle hatchStyle = static_cast<System::Drawing::Drawing2D::HatchStyle>(0); hatchStyle <= (System::Drawing::Drawing2D::HatchStyle)52; hatchStyle++)
            {
                //Set paint with current hatch brush style
                document->SetPaint(System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(hatchStyle, System::Drawing::Color::get_Black(), System::Drawing::Color::get_White()));
                
                //Calculate displacement in order to don't go beyond the page bounds
                int32_t x = squareSide;
                int32_t y = 0;
                if (sumX >= width)
                {
                    x = -(sumX - squareSide);
                    y += squareSide;
                }
                //Translate current graphics state
                document->Translate(static_cast<float>(x), static_cast<float>(y));
                //Fill pattern square
                document->Fill(path);
                //Set stroke
                document->SetStroke(pen);
                //Draw square outline
                document->Draw(path);
                
                //Calculate distance from X0
                if (sumX >= width)
                {
                    sumX = squareSide;
                }
                else
                {
                    sumX += x;
                }
            }
            
            //Restore graphics state
            document->WriteGraphicsRestore();
            
            //Fill text with hatch pattern
            System::SharedPtr<System::Drawing::Drawing2D::HatchBrush> brush = System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(System::Drawing::Drawing2D::HatchStyle::DiagonalCross, System::Drawing::Color::get_Red(), System::Drawing::Color::get_Yellow());
            System::SharedPtr<System::Drawing::Font> font = System::MakeObject<System::Drawing::Font>(u"Arial", 96.0f, System::Drawing::FontStyle::Bold);
            document->FillAndStrokeText(u"ABC", font, 200.0f, 300.0f, brush, pen);
            
            //Outline text with hatch pattern
            brush = System::MakeObject<System::Drawing::Drawing2D::HatchBrush>(System::Drawing::Drawing2D::HatchStyle::Percent50, System::Drawing::Color::get_Blue(), System::Drawing::Color::get_White());
            document->OutlineText(u"ABC", font, 200.0f, 400.0f, System::MakeObject<System::Drawing::Pen>(brush, 5.0f));
            
            
            //Close current page
            document->ClosePage();
            
            //Save the document
            document->Save();
        }
        catch(...)
        {
            __dispose_guard_0.SetCurrentException(std::current_exception());
        }
    }

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

The result of running this code is appeared as

You can download examples and data files from GitHub.