Impressão

Este guia mostra como trabalhar com a API de impressão.

Visão Geral

A página Web pode ser impressa através de uma das seguintes formas:

Utilizando a função JavaScript window.print(). Esta função pode ser invocada a partir do código JavaScript numa página Web.
Utilizar o método Frame.print() da API JxBrowser. O método solicita a impressão do frame. Se precisar imprimir a página inteira, você deve chamar o método print() no frame principal. Por exemplo:
Java
Kotlin
```
browser.mainFrame().ifPresent(Frame::print);
```
```
browser.mainFrame?.print()
```

A página Web não é impressa imediatamente. O PrintCallback será invocado para dizer ao navegador como lidar com o pedido de impressão. Por padrão, todos os pedidos de impressão são cancelados.

Pré-Visualização de Impressão

Para permitir o pedido de impressão e apresentar a caixa de diálogo Visualização da Impressão, utilize o seguinte código:

Java
Kotlin
browser.set(PrintCallback.class, (params, tell) -> tell.showPrintPreview());
browser.register(PrintCallback { params, tell ->
    tell.showPrintPreview()
})

Na caixa de diálogo Pré-visualização da Impressão, você pode selecionar as opções de impressão preferidas:

Pré-visualização da Impressão

Configurando as Definições

Diga ao navegador para prosseguir com a impressão utilizando o seguinte código:

Java
Kotlin
browser.set(PrintCallback.class, (params, tell) -> tell.print());
browser.register(PrintCallback { params, tell ->
    tell.print()
})

Depois disso, o PrintHtmlCallback ou o PrintPdfCallback serão invocados para permitir a configuração das definições de impressão. Estas chamadas de retorno correspondem ao tipo de conteúdo que está atualmente carregado no navegador. Para conteúdo HTML é invocado o PrintHtmlCallback e para conteúdo PDF o PrintPdfCallback.

Agora, vamos ver como trabalhar com estas chamadas de retorno.

Passo 1: Escolher a Impressora

Em primeiro lugar, é necessário escolher a impressora em que deseja imprimir. Existem dois tipos de impressoras: PdfPrinter e SystemPrinter. O PdfPrinter é um equivalente da opção Salvar como PDF na caixa de diálogo Visualizar Impressão. O tipo SystemPrinter representa uma impressora instalada no sistema, podendo ser virtual ou física. Os parâmetros da chamada de retorno fornecem uma lista das impressoras disponíveis. Você pode obter a PdfPrinter, a impressora predefinida do sistema, ou escolher uma impressora entre as impressoras do sistema:

Java
Kotlin
browser.set(PrintHtmlCallback.class, (params, tell) -> {
    // A impressora PDF está sempre disponível.
    var pdfPrinter = params.printers().pdfPrinter();

    // A impressora padrão é opcional.
    var defaultPrinter = params.printers()
        .defaultPrinter()
        .orElseThrow(() -> new IllegalStateException("A impressora predefinida não foi encontrada."));

    // Encontrar uma impressora de sistema pelo nome.
    var systemPrinter = params.printers()
        .list()
        .stream()
        .filter(printer -> printer.deviceName().equals("Microsoft XPS Document Writer"))
        .findFirst()
        .orElseThrow(() -> new IllegalStateException("A impressora não foi encontrada."));
});
browser.register(PrintHtmlCallback { params, tell ->
    // A impressora PDF está sempre disponível.
    val pdfPrinter = params.printers.pdf

    // A impressora padrão é opcional.
    val defaultPrinter = params.printers.default!!

    // Localizar uma impressora do sistema pelo nome.
    val systemPrinter = params.printers.list()
        .firstOrNull { it.deviceName() == "Microsoft XPS Document Writer" }
        ?: throw IllegalStateException("A impressora não funciona.")
})

Passo 2: Configurar as Definições

Cada impressora é parametrizada com um tipo PrintSettings que define as configurações de impressão disponíveis para a impressora no contexto atual. Cada impressora contém um PrintJob que representa a operação de impressão atual. As definições de impressão são aplicadas a um trabalho de impressão:

Java
Kotlin
var printer = params.printers()
    .defaultPrinter()
    .orElseThrow(IllegalStateException::new);
var printJob = printer.printJob();
printJob.settings()
    .header("<span style='font-size: 12px;'>Page header:</span>"
        + "<span class='title'></span>")
    .footer("<span style='font-size: 12px;'>Page footer:</span>"
        + "<span class='pageNumber'></span>")
    .paperSize(ISO_A4)
    .colorModel(COLOR)
    .enablePrintingBackgrounds()
    .disablePrintingHeaderFooter()
    .orientation(PORTRAIT)
    .apply();
val printer = params.printers.default!!
val printJob = printer.job
printJob.settings()
    .header(
        "<span style='font-size: 12px;'>Page header:</span>"
                + "<span class='title'></span>"
    )
    .footer(
        "<span style='font-size: 12px;'>Page footer:</span>"
                + "<span class='pageNumber'></span>"
    )
    .paperSize(ISO_A4)
    .colorModel(COLOR)
    .enablePrintingBackgrounds()
    .disablePrintingHeaderFooter()
    .orientation(PORTRAIT)
    .apply()

A chamada do método apply() aplicará as definições configuradas e gerará novamente o documento de pré-visualização de impressão que será posteriormente enviado para a impressora. Antes de dizer ao navegador para começar a imprimir na impressora, você pode se inscrever ao evento PrintCompleted para receber uma notificação quando a impressão em estiver concluída:

Java
Kotlin
printJob.on(PrintCompleted.class, event -> {
    if (event.isSuccess()) {
        System.out.println("A impressão foi concluída com sucesso.");
    } else {
        System.out.println("A impressão falhou.");
    }
});
printJob.subscribe<PrintCompleted> { event ->
    if (event.isSuccess) {
        println("A impressão foi concluída com sucesso.")
    } else {
        println("A impressão falhou.")
    }
}

Passo 3: Iniciar a Impressão

Agora estamos prontos para começar a imprimir:

Java
Kotlin
tell.proceed(printer);
tell.proceed(printer)

Aqui está o trecho de código completo:

Java
Kotlin
browser.set(PrintHtmlCallback.class, (params, tell) -> {
    var printer = params.printers()
        .defaultPrinter()
        .orElseThrow(IllegalStateException::new);
    var printJob = printer.printJob();
    printJob.settings()
        .header("<span style='font-size: 12px;'>Page header:</span>"
            + "<span class='title'></span>")
        .footer("<span style='font-size: 12px;'>Page footer:</span>"
            + "<span class='pageNumber'></span>")
        .paperSize(ISO_A4)
        .colorModel(COLOR)
        .enablePrintingBackgrounds()
        .disablePrintingHeaderFooter()
        .orientation(PORTRAIT)
        .apply();
    printJob.on(PrintCompleted.class, event -> {
        if (event.isSuccess()) {
            System.out.println("A impressão foi concluída com sucesso.");
        } else {
            System.out.println("A impressão falhou.");
        }
    });
    tell.proceed(printer);
});
browser.register(PrintHtmlCallback { params, tell ->
    val printer = params.printers.default!!
    val printJob = printer.job
    printJob.settings()
        .header("<span style='font-size: 12px;'>Page header:</span>"
                + "<span class='title'></span>")
        .footer("<span style='font-size: 12px;'>Page footer:</span>"
                + "<span class='pageNumber'></span>")
        .paperSize(ISO_A4)
        .colorModel(COLOR)
        .enablePrintingBackgrounds()
        .disablePrintingHeaderFooter()
        .orientation(PORTRAIT)
        .apply()
    printJob.subscribe<PrintCompleted> { event ->
        if (event.isSuccess) {
            println("A impressão foi concluída com sucesso.")
        } else {
            println("A impressão falhou.")
        }
    }
    tell.proceed(printer)
})

A impressão na PdfPrinter é idêntica, exceto que é necessário especificar o caminho do arquivo PDF de destino:

Java
Kotlin
browser.set(PrintHtmlCallback.class, (params, tell) -> {
    var printer = params.printers().pdfPrinter();
    var printJob = printer.printJob();
    printJob.settings()
        .paperSize(ISO_A4)
        .enablePrintingBackgrounds()
        .pdfFilePath(Paths.get("<path-to-pdf-file>"))
        .apply();
    printJob.on(PrintCompleted.class, event -> {
        if (event.isSuccess()) {
            System.out.println("A impressão foi concluída com sucesso.");
        } else {
            System.out.println("A impressão falhou.");
        }
    });
    tell.proceed(printer);
});
browser.register(PrintHtmlCallback { params, tell ->
    val printer = params.printers.pdf
    val printJob = printer.job
    printJob.settings()
        .paperSize(ISO_A4)
        .enablePrintingBackgrounds()
        .pdfFilePath(Path("<path-to-pdf-file>"))
        .apply()
    printJob.subscribe<PrintCompleted> { event ->
        if (event.isSuccess) {
            println("A impressão foi concluída com sucesso.")
        } else {
            println("A impressão falhou.")
        }
    }
    tell.proceed(printer)
})

O PrintPdfCallback tem a mesma interface e a única diferença reside nas definições de impressão que podem ser aplicadas a uma tarefa de impressão.

Cancelar a Impressão

Para cancelar a impressão, utilize a seguinte abordagem:

Java
Kotlin
browser.set(PrintCallback.class, (params, tell) -> tell.cancel());
browser.register(PrintCallback { params, tell ->
    tell.cancel()
})

Introdução

Instalação

Guias

Resolução de Problemas