Skip to content

DocumentFilters::MakeOutputCanvas method

Creates a new canvas that is used for rendering page content. The output data will be written to the file specified in Filename.

Overloads

MakeOutputCanvas(string, int, string) Create a new canvas writing to a file.
MakeOutputCanvas(stream, int, string) Create a new canvas writing to a stream.

MakeOutputCanvas(string, int, string)

Prototype

Canvas MakeOutputCanvas(string filename, int canvasType, string options)

Canvas MakeOutputCanvas(string filename, int canvasType, string options) throws IGRException;

def MakeOutputCanvas(self, filename: string, canvasType: int, options: string) -> Canvas

Canvas MakeOutputCanvas(const std::wstring& filename, int canvasType, const std::wstring& options = std::wstring(L""))

Canvas* MakeOutputCanvas(std::wstring filename, int canvasType, std::wstring options)

HRESULT MakeOutputCanvas([in] BSTR filename, [in] int canvasType, [in] BSTR options, [out, retval] Canvas* *result)

Parameters

filename: string : Filename where canvas is to be created

canvasType: int : Indicates the type of output device to create; see Canvas Types for details.

options: string : Semicolon separated list of name value pair options; see Constants and Codes for details.

Return value

Canvas : The newly created canvas object.

MakeOutputCanvas(stream, int, string)

Prototype

Canvas MakeOutputCanvas(System.IO.Stream stream, int canvasType, string options)

Canvas MakeOutputCanvas(IGRStream stream, int canvasType, string options) throws IGRException;

def MakeOutputCanvas(self, stream: Stream, canvasType: int, options: string) -> Canvas

Canvas MakeOutputCanvas(Stream& stream, int canvasType, const std::wstring& options = std::wstring(L""));
Canvas MakeOutputCanvas(std::iostream& stream, CanvasType type, const std::wstring& options);
Canvas MakeOutputCanvas(std::iostream* stream, bool own_stream, CanvasType type, const std::wstring& options);
Canvas MakeOutputCanvas(Stream* stream, bool own_stream, bool own_stream, CanvasType type, const std::wstring& options);

Canvas* MakeOutputCanvas(Stream* stream, int canvasType, std::wstring options)

HRESULT MakeOutputCanvasOnStream([in] IStream* stream, [in] int canvasType, [in] BSTR options, [out, retval] Canvas* *result)

Parameters

stream: stream : Stream where canvas is to be created

canvasType: int : Indicates the type of output device to create; see Canvas Types for details.

options: string : Semicolon separated list of name value pair options; see Constants and Codes for details.

Return value

Canvas : The newly created canvas object.

Sample Code

1
2
3
4
5
6
7
8
9
using Hyland.DocumentFilters;

var api = new Hyland.DocumentFilters.Api();
api.Initialize("License Code", ".");

using var doc = api.OpenExtractor("filename.doc", OpenMode.Paginated);
using var canvas = api.MakeOutputCanvas("filename.pdf", CanvasType.PDF);

canvas.RenderPages(doc);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import com.perceptive.documentfilters.*;

public class hidef_pdf
{
    public static void main(String[] args) throws Exception
    {
        DocumentFilters df = new DocumentFilters();
        df.Initialize(("License Code"), ".");

        try (Extractor doc = df.GetExtractor("filename.doc"))
        {
            try (Canvas canvas = df.MakeOutputCanvas("filename.pdf", isys_docfiltersConstants.IGR_DEVICE_IMAGE_PDF, ""))
            {
                doc.Open(isys_docfiltersConstants.IGR_FORMAT_IMAGE, "");

                for (int i = 0, c = doc.GetPageCount(); i < c; ++i)
                {
                    try (Page page = doc.GetPage(i)) {
                        canvas.RenderPage(page);
                    }
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
from DocumentFilters import *

api = DocumentFilters()
api.Initialize("License Code", ".")

with api.OpenExtractor("filename.doc", mode=IGR_FORMAT_IMAGE) as doc:
    with api.MakeOutputCanvas("filename.pdf", canvasType=IGR_DEVICE_PDF) as canvas:
        canvas.RenderPages(doc)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <DocumentFiltersObjects.h>

int main() {
    try {
        // Create and initialize the API object
        Hyland::DocFilters::Api api;
        api.Initialize("License Code", ".");

        // Open the input file
        Hyland::DocFilters::Extractor doc = api.OpenExtractor("filename.doc", Hyland::DocFilters::OpenMode::Paginated);

        // Create the output canvas 
        Hyland::DocFilters::Canvas canvas = api.MakeOutputCanvas("output.pdf", Hyland::DocFilters::CanvasType::PDF);

        // Render all pages to the output
        canvas.RenderPages(doc);
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1; // Indicate an error
    }

    return 0; // Successful execution
}

Additional Information

For output formats that support multiple pages, you may choose to write multiple input documents to a single output document.

See Also