Como criar lista suspensa pdf em Java com GroupDocs

Criar uma create pdf dropdown list em Java é uma necessidade comum para quem desenvolve PDFs interativos—seja para pesquisas, formulários de pedido ou fluxos de aprovação. Neste tutorial você aprenderá a usar o GroupDocs.Annotation para adicionar componentes de lista suspensa aos seus PDFs, configurar opções dinamicamente e lidar com documentos grandes de forma eficiente. Vamos percorrer cada passo, desde a configuração do ambiente até as melhores práticas prontas para produção, para que você possa entregar formulários robustos e interativos sem lutar com os detalhes internos de PDF de baixo nível.

Respostas rápidas

  • Qual biblioteca é a melhor para adicionar listas suspensas em PDFs Java? GroupDocs.Annotation fornece uma API Java concisa para criar e gerenciar campos de formulário PDF.
  • Preciso de licença para desenvolvimento? Um teste gratuito funciona para testes; uma licença de produção é necessária para uso comercial.
  • Posso posicionar a lista suspensa em qualquer lugar da página? Sim – use o método setBox com coordenadas PDF (origem no canto inferior esquerdo).
  • Como evito problemas de memória com PDFs grandes? Use try‑with‑resources, processe arquivos um de cada vez e aumente o heap da JVM se necessário.
  • É possível carregar opções de um banco de dados? Absolutamente – preencha a lista de opções dinamicamente antes de chamar setOptions.

O que é create pdf dropdown list?

Uma operação create pdf dropdown list adiciona um campo selecionável a um PDF, semelhante a um elemento HTML <select>, permitindo que os usuários finais escolham um valor de um conjunto predefinido. Esse elemento interativo é armazenado diretamente no arquivo PDF, funcionando em qualquer visualizador compatível com padrões sem scripts adicionais.

Por que escolher GroupDocs para listas suspensas PDF?

GroupDocs.Annotation foi projetado para processamento de documentos em alto volume e nível empresarial. Ele suporta mais de 50 formatos de entrada e saída, pode lidar com PDFs com até 1.000 páginas sem carregar todo o arquivo na memória e oferece uma API de linha única para criar listas suspensas. Essas capacidades quantificadas o tornam uma escolha confiável para o caso de uso create pdf dropdown list.

Pré-requisitos e configuração

O que você precisará

Você precisa de um ambiente de desenvolvimento Java moderno:

  • Java Development Kit (JDK) – versão 8 ou mais recente; JDK 11+ é recomendado para suporte de longo prazo.
  • Maven – para gerenciamento de dependências (Gradle também funciona, mas o Maven é demonstrado).
  • IDE – IntelliJ IDEA, Eclipse ou VS Code com extensões Java.
  • Conhecimento básico de Java – familiaridade com classes, objetos e a construção try‑with‑resources.

Configuração do Maven

Adicione o GroupDocs.Annotation ao seu projeto inserindo o seguinte no seu pom.xml:

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/annotation/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-annotation</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

Dica profissional: Sempre verifique a versão mais recente no site do GroupDocs. Usar versões desatualizadas pode causar problemas de compatibilidade e recursos ausentes.

Configuração de licença

Para aprendizado/testes:

  1. Baixe o teste gratuito em Teste Gratuito GroupDocs
  2. A versão de teste inclui marcas d’água, mas oferece funcionalidade completa.

Para produção:

Você também pode baixar a biblioteca no Centro de Download. Para mais detalhes, veja a Referência da API. Documentação adicional está disponível na Documentação GroupDocs. Explore opções de compra em Opções de Compra. Experimente o Teste Gratuito para avaliar recursos. Obtenha ajuda no Fórum de Suporte.

Padrão básico de inicialização

GroupDocs.Annotation for Java é uma biblioteca que permite adicionar anotações e campos de formulário interativos a PDFs e outros tipos de documentos programaticamente. A classe Annotator é o componente central que carrega um documento e fornece métodos para criar, editar e salvar anotações. Aqui está a base que você usará para todas as operações do GroupDocs:

try (final Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf")) {
    // Your annotation magic happens here
    // The try-with-resources ensures proper cleanup
}

Por que esse padrão importa: A instrução try‑with‑resources fecha automaticamente o annotator, evitando vazamentos de memória – um problema comum ao trabalhar com bibliotecas PDF.

Como adicionar lista suspensa em PDFs Java

Carregue seu PDF com new Annotator("input.pdf"), crie um campo de lista suspensa, defina suas opções, posicione-o usando setBox e, finalmente, salve o documento. Esse fluxo conciso permite create pdf dropdown list em apenas algumas chamadas de API, mantendo seu código limpo e fácil de manter.

Desempenho e suporte a formatos

GroupDocs oferece um motor de anotação dedicado que suporta mais de 50 formatos de entrada e saída, fornece uma API Java simples para campos de formulário e lida com documentos grandes sem carregar todo o arquivo na memória, tornando‑o ideal para criar listas suspensas PDF. Seus benchmarks de desempenho mostram o processamento de um PDF de 500 páginas em menos de 10 segundos em um servidor padrão.

Entendendo componentes de lista suspensa

Um componente de lista suspensa PDF é essencialmente um campo de formulário que apresenta ao usuário uma lista predefinida de opções. Pense nele como um elemento HTML <select>, mas incorporado diretamente no documento PDF.

Casos de uso comuns:

  • Seleção de país/estado em formulários de registro
  • Categorias de produto em formulários de pedido
  • Atualizações de status em documentos de fluxo de trabalho
  • Escalas de avaliação em pesquisas de feedback

Criando sua primeira lista suspensa

Etapa 1: inicializar o annotator

Annotator é a classe central que carrega um documento e fornece métodos para criar, editar e salvar anotações. Comece configurando seu processador de documentos:

try (final Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf")) {
    // We'll build our dropdown here
}

Nota importante: Substitua "YOUR_DOCUMENT_DIRECTORY/input.pdf" pelo caminho real do seu arquivo PDF. Um erro comum é usar caminhos relativos que quebram ao executar a partir de diretórios diferentes.

Etapa 2: criar o componente de lista suspensa

Dropdown é o objeto que representa um campo de lista selecionável em um PDF. Criar um componente de lista suspensa vazio é o primeiro bloco de construção:

// Create a new DropdownComponent object
dropdownComponent = new DropdownComponent();

Etapa 3: configurar opções da lista suspensa

setOptions atribui os itens selecionáveis que aparecem em um campo de lista suspensa. Você pode passar uma lista de strings que representam cada escolha:

dropdownComponent.setOptions(new ArrayList<>(Arrays.asList("Item1", "Item2", "Item3")));

Exemplo do mundo real: Para uma pesquisa de satisfação do cliente, você poderia usar:

dropdownComponent.setOptions(new ArrayList<>(Arrays.asList(
    "Very Satisfied", 
    "Satisfied", 
    "Neutral", 
    "Dissatisfied", 
    "Very Dissatisfied"
)));

Etapa 4: posicionar e dimensionar a lista suspensa

setBox define a área retangular (posição e tamanho) de um campo de formulário em uma página PDF. As coordenadas PDF começam no canto inferior esquerdo (diferente do HTML, que começa no canto superior esquerdo). Portanto, (100, 100) significa 100 pontos para a direita e 100 pontos para cima a partir do canto inferior esquerdo.

dropdownComponent.setBox(new Rectangle(100, 100, 50, 20)); // x, y, width, height

Dicas de dimensionamento:

  • A largura deve acomodar o texto da opção mais longa.
  • Altura de 20‑25 pontos geralmente funciona bem para texto padrão.
  • Teste com valores diferentes para encontrar o que fica melhor no seu documento.

Etapa 5: adicionar e salvar

Finalmente, integre sua lista suspensa ao documento e persista as alterações. Sempre salve com um nome de arquivo diferente durante o desenvolvimento para evitar sobrescrever o arquivo original.

annotator.add(dropdownComponent);
// Save changes to a new file or overwrite the existing one
annotator.save("YOUR_DOCUMENT_DIRECTORY/output.pdf");

Exemplo completo em funcionamento

Aqui está tudo reunido em um exemplo completo e executável que demonstra o fluxo create pdf dropdown list do início ao fim:

import com.groupdocs.annotation.Annotator;
import com.groupdocs.annotation.models.annotationmodels.DropdownComponent;
import com.groupdocs.annotation.models.Rectangle;
import java.util.ArrayList;
import java.util.Arrays;

public class PDFDropdownExample {
    public static void main(String[] args) {
        try (final Annotator annotator = new Annotator("input.pdf")) {
            // Create dropdown component
            DropdownComponent dropdownComponent = new DropdownComponent();
            
            // Set dropdown options
            dropdownComponent.setOptions(new ArrayList<>(Arrays.asList(
                "Priority: High", 
                "Priority: Medium", 
                "Priority: Low"
            )));
            
            // Position the dropdown
            dropdownComponent.setBox(new Rectangle(150, 300, 120, 25));
            
            // Add to document and save
            annotator.add(dropdownComponent);
            annotator.save("output_with_dropdown.pdf");
            
            System.out.println("Dropdown successfully added to PDF!");
        } catch (Exception e) {
            System.err.println("Error creating dropdown: " + e.getMessage());
        }
    }
}

Armadilhas comuns e como evitá‑las

Problema 1: erros “File not found”

Problema: Seu código lança FileNotFoundException mesmo que o arquivo exista.
Solução: Verifique se o caminho do arquivo é absoluto ou está corretamente resolvido em relação ao diretório de trabalho, e assegure que a aplicação tenha permissões de leitura.

// Instead of relative paths like this:
new Annotator("input.pdf")

// Use absolute paths or properly constructed relative paths:
new Annotator(System.getProperty("user.dir") + "/documents/input.pdf")
// Or use Path.resolve() for more robust path handling

Problema 2: lista suspensa aparece no local errado

Problema: Sua lista suspensa aparece em um lugar inesperado no PDF.
Causa raiz: Confusão no sistema de coordenadas PDF.
Solução: Lembre‑se de que (0,0) está no canto inferior esquerdo nos PDFs. Use um visualizador que exiba coordenadas, comece com valores Y maiores e ajuste gradualmente para baixo.

Problema 3: erros de tempo de execução relacionados à licença

Problema: O código funciona no desenvolvimento, mas falha na produção com erros de licença.
Correções rápidas:

  1. Verifique se o arquivo de licença está no classpath.
  2. Confira as datas de expiração da licença.
  3. Assegure que a licença corresponda ao seu ambiente de implantação (licenças de dev vs. produção são diferentes).

Problema 4: problemas de memória com PDFs grandes

Problema: OutOfMemoryError ao processar documentos grandes.
Soluções: Use o padrão try‑with‑resources, processe arquivos um de cada vez e aumente o tamanho do heap da JVM (-Xmx) conforme necessário.

// Set JVM memory parameters
// -Xmx2g -Xms1g

// Process documents in batches if possible
// Dispose of annotator objects properly (use try-with-resources)

Exemplos de implementação do mundo real

Exemplo 1: formulário de feedback de funcionários

public void createFeedbackForm(String inputPdf, String outputPdf) {
    try (final Annotator annotator = new Annotator(inputPdf)) {
        // Department selection dropdown
        DropdownComponent deptDropdown = new DropdownComponent();
        deptDropdown.setOptions(new ArrayList<>(Arrays.asList(
            "Engineering", "Marketing", "Sales", "HR", "Finance"
        )));
        deptDropdown.setBox(new Rectangle(200, 500, 100, 25));
        
        // Performance rating dropdown
        DropdownComponent ratingDropdown = new DropdownComponent();
        ratingDropdown.setOptions(new ArrayList<>(Arrays.asList(
            "Exceeds Expectations", "Meets Expectations", "Below Expectations"
        )));
        ratingDropdown.setBox(new Rectangle(200, 450, 150, 25));
        
        annotator.add(deptDropdown);
        annotator.add(ratingDropdown);
        annotator.save(outputPdf);
    } catch (Exception e) {
        log.error("Failed to create feedback form: {}", e.getMessage());
    }
}

Exemplo 2: formulário de pedido com opções dinâmicas

Este exemplo mostra como você pode preencher as opções da lista suspensa a partir de um banco de dados:

public void createOrderForm(String inputPdf, List<String> products) {
    try (final Annotator annotator = new Annotator(inputPdf)) {
        DropdownComponent productDropdown = new DropdownComponent();
        
        // Add a default option
        List<String> options = new ArrayList<>();
        options.add("-- Select Product --");
        options.addAll(products);
        
        productDropdown.setOptions(options);
        productDropdown.setBox(new Rectangle(150, 400, 200, 25));
        
        annotator.add(productDropdown);
        annotator.save("order_form_" + System.currentTimeMillis() + ".pdf");
    } catch (Exception e) {
        throw new RuntimeException("Order form creation failed", e);
    }
}

Dicas de otimização de desempenho

Gerenciamento de memória

Ao processar múltiplos PDFs ou documentos grandes, o gerenciamento de memória torna‑se crucial:

// Good: Process documents one at a time
for (String pdfFile : pdfFiles) {
    try (final Annotator annotator = new Annotator(pdfFile)) {
        // Process individual file
        addDropdowns(annotator);
        annotator.save(getOutputPath(pdfFile));
    } // Annotator automatically closed here
}

// Avoid: Creating multiple annotators simultaneously
// This can quickly exhaust memory

Estratégia de processamento em lote

Para cenários de alto volume, processe cada arquivo em seu próprio bloco try‑with‑resources e libere recursos prontamente:

public void processBatch(List<String> pdfFiles, int batchSize) {
    for (int i = 0; i < pdfFiles.size(); i += batchSize) {
        List<String> batch = pdfFiles.subList(i, 
            Math.min(i + batchSize, pdfFiles.size()));
        
        processBatchOfFiles(batch);
        
        // Force garbage collection between batches
        System.gc();
    }
}

Considerações de cache

Se você estiver processando documentos semelhantes repetidamente, faça cache de objetos reutilizáveis como a instância de licença e reutilize a mesma configuração do Annotator sempre que possível:

// Cache dropdown configurations
private static final Map<String, List<String>> DROPDOWN_OPTIONS = Map.of(
    "countries", Arrays.asList("USA", "Canada", "UK", "Germany"),
    "priorities", Arrays.asList("High", "Medium", "Low")
);

public DropdownComponent createStandardDropdown(String type, Rectangle position) {
    DropdownComponent dropdown = new DropdownComponent();
    dropdown.setOptions(new ArrayList<>(DROPDOWN_OPTIONS.get(type)));
    dropdown.setBox(position);
    return dropdown;
}

Técnicas avançadas

Estilizando listas suspensas

Embora o GroupDocs.Annotation foque em funcionalidade mais do que em personalização visual, ainda é possível influenciar a aparência definindo tamanho da fonte, cor e propriedades de borda no campo de lista suspensa.

dropdownComponent.setBox(new Rectangle(100, 100, 150, 30)); // Wider for better readability
// The library handles font and color based on PDF defaults

Criação condicional de listas suspensas

Às vezes você precisa de listas suspensas apenas sob certas condições (por exemplo, com base no papel do usuário). Use instruções if padrão do Java para decidir se deve instanciar e adicionar o componente de lista suspensa.

public void addConditionalDropdowns(Annotator annotator, DocumentType docType) {
    if (docType == DocumentType.SURVEY) {
        addSurveyDropdowns(annotator);
    } else if (docType == DocumentType.ORDER_FORM) {
        addOrderDropdowns(annotator);
    }
}

Integração com validação de formulário

Enquanto o GroupDocs cuida da criação da lista suspensa, você pode querer validar os PDFs após a criação—garantir que campos obrigatórios estejam preenchidos, que opções estejam dentro dos intervalos permitidos e que o documento cumpra suas regras de negócio.

public boolean validateDropdownsAdded(String pdfPath) {
    try (final Annotator annotator = new Annotator(pdfPath)) {
        // Check if annotations were added successfully
        return annotator.get().size() > 0;
    } catch (Exception e) {
        return false;
    }
}

Guia de solução de problemas

Modo de depuração

Habilite o registro detalhado para diagnosticar problemas:

// Add this to your logging configuration
Logger.getLogger("com.groupdocs").setLevel(Level.DEBUG);

Mensagens de exceção comuns e soluções

ExceçãoCausa provávelSolução
FileNotFoundExceptionCaminho de arquivo incorretoUse caminhos absolutos ou verifique a lógica de caminho relativo
InvalidLicenseExceptionProblemas de licençaVerifique a localização e a validade do arquivo de licença
OutOfMemoryErrorProcessamento de arquivo grandeAumente o heap da JVM ou processe em lotes
UnsupportedOperationExceptionRestrições do PDFVerifique se o PDF permite modificações

Testando sua implementação

Crie um teste simples para verificar se tudo funciona:

@Test
public void testDropdownCreation() {
    String inputFile = "test-input.pdf";
    String outputFile = "test-output.pdf";
    
    try (final Annotator annotator = new Annotator(inputFile)) {
        DropdownComponent dropdown = new DropdownComponent();
        dropdown.setOptions(Arrays.asList("Test1", "Test2"));
        dropdown.setBox(new Rectangle(100, 100, 80, 20));
        
        annotator.add(dropdown);
        annotator.save(outputFile);
        
        // Verify output file exists and has content
        assertTrue(Files.exists(Paths.get(outputFile)));
        assertTrue(Files.size(Paths.get(outputFile)) > 0);
    }
}

Considerações de implantação em produção

Estratégia de tratamento de erros

Implemente um manejo robusto de erros para ambientes de produção, capturando e registrando exceções sem expor rastreamentos de pilha aos usuários finais:

public class PDFDropdownService {
    private static final Logger logger = LoggerFactory.getLogger(PDFDropdownService.class);
    
    public Result<String> addDropdownToPDF(String inputPath, DropdownConfig config) {
        try (final Annotator annotator = new Annotator(inputPath)) {
            DropdownComponent dropdown = createDropdownFromConfig(config);
            annotator.add(dropdown);
            
            String outputPath = generateOutputPath(inputPath);
            annotator.save(outputPath);
            
            logger.info("Successfully added dropdown to PDF: {}", outputPath);
            return Result.success(outputPath);
            
        } catch (Exception e) {
            logger.error("Failed to add dropdown to PDF: {}", e.getMessage(), e);
            return Result.error("PDF processing failed: " + e.getMessage());
        }
    }
}

Gerenciamento de configuração

Armazene opções de lista suspensa e outros valores configuráveis em arquivos de propriedades externos ou em um banco de dados, permitindo atualizações sem recompilar a aplicação:

# dropdown-config.yml
dropdowns:
  priority:
    options: ["High", "Medium", "Low"]
    position: {x: 100, y: 200, width: 80, height: 25}
  status:
    options: ["New", "In Progress", "Completed"]
    position: {x: 200, y: 200, width: 100, height: 25}

Recursos adicionais

Conclusão e próximos passos

Parabéns! Agora você domina como adicionar lista suspensa a formulários PDF interativos usando o GroupDocs.Annotation para Java. Aprendeu tudo, desde a configuração básica até técnicas avançadas de otimização que serão úteis em ambientes de produção.

Principais pontos

  • Configuração é simples: integração Maven e licenciamento são mais fáceis que a maioria das bibliotecas PDF.
  • API é intuitiva: o design segue convenções Java familiares, reduzindo a curva de aprendizado.
  • Desempenho importa: gerenciamento adequado de recursos evita problemas de memória mesmo com PDFs de centenas de páginas.
  • Teste é crucial: verifique seus PDFs em diferentes visualizadores para garantir comportamento consistente.

O que vem a seguir?

Agora que você tem o fluxo create pdf dropdown list sob controle, considere explorar esses recursos relacionados:

  1. Anotações de campo de texto – capture entrada livre do usuário.
  2. Componentes de caixa de seleção – habilite seleções booleanas.
  3. Campos de assinatura – suporte aprovações legais diretamente no PDF.
  4. Marca d’água – personalize seus documentos com logos ou avisos de confidencialidade.
  5. Comparação de documentos – rastreie alterações entre diferentes versões de um formulário.

Pronto para avançar?

Confira estes recursos para aprofundar sua expertise no GroupDocs:

Lembre‑se, a melhor forma de dominar qualquer tecnologia é construindo algo com ela. Comece com um formulário simples de feedback para sua equipe, depois adicione campos mais complexos à medida que se sentir confortável com a API.

Tem dúvidas ou encontrou problemas? A comunidade GroupDocs é extremamente prestativa, e a documentação é realmente legível (eu sei, raro em ferramentas para desenvolvedores!).

Feliz codificação, e que seus PDFs sejam sempre interativos! 🚀

Perguntas frequentes

O que é exatamente o GroupDocs.Annotation para Java?

GroupDocs.Annotation for Java é uma biblioteca abrangente que permite adicionar vários tipos de anotações a documentos, incluindo PDFs. Pense nela como sua caixa de ferramentas para tornar documentos estáticos interativos – você pode adicionar listas suspensas, campos de texto, caixas de seleção, assinaturas e muito mais sem precisar entender a complexa estrutura interna do PDF.

Quão difícil é configurar o GroupDocs no meu projeto existente?

É surpreendentemente simples! Se você usa Maven, basta adicionar o repositório e a dependência ao seu pom.xml. Toda a configuração leva cerca de cinco minutos. A parte mais complicada costuma ser a configuração da licença, mas a documentação orienta passo a passo.

Posso usar o GroupDocs para formatos de arquivo além de PDF?

Absolutamente! O GroupDocs suporta uma ampla gama de formatos, incluindo documentos Word, planilhas Excel, apresentações PowerPoint e vários formatos de imagem. A API permanece consistente entre os formatos, então, depois de aprendê‑la para PDFs, você pode aplicá‑la facilmente em outros contextos.

O que devo fazer se minha lista suspensa aparecer na posição errada?

Isso geralmente ocorre por confusão no sistema de coordenadas. Lembre‑se de que PDFs usam origem no canto inferior esquerdo (diferente das páginas web que usam canto superior esquerdo). Comece com valores Y maiores e vá ajustando gradualmente para baixo. Muitos visualizadores de PDF podem exibir as coordenadas exatas dos objetos selecionados—use isso para afinar o posicionamento.

Existe uma maneira de testar minha implementação sem uma licença completa?

Sim! O GroupDocs oferece um teste gratuito que inclui todas as funcionalidades. A única limitação é que os documentos processados terão uma marca d’água. Isso é perfeito para desenvolvimento e testes – você pode verificar tudo antes de comprar uma licença de produção.

Como lidar com arquivos PDF grandes sem ficar sem memória?

Ótima pergunta! Use religiosamente o padrão try‑with‑resources – ele garante a limpeza adequada. Para processamento em lote, trate os arquivos um de cada vez em vez de carregar vários PDFs simultaneamente. Você também pode precisar aumentar o heap da JVM (-Xmx) dependendo do tamanho dos arquivos.

Posso personalizar a aparência das listas suspensas?

O GroupDocs foca mais na funcionalidade do que na personalização visual. As listas suspensas herdam o estilo padrão do PDF. No entanto, você pode controlar tamanho e posição com precisão. Se precisar de personalização visual pesada, talvez seja necessário recorrer a bibliotecas PDF mais especializadas, mas o estilo padrão funciona bem para a maioria das aplicações empresariais.

Qual a melhor forma de obter ajuda se eu estiver preso?

O Fórum de Suporte GroupDocs é extremamente ativo e útil. A comunidade inclui usuários e funcionários do GroupDocs que respondem rapidamente. Além disso, a documentação é realmente boa (eu sei, surpreendente para uma ferramenta de desenvolvedor!), então verifique lá primeiro.

Existem armadilhas de licenciamento que eu devo conhecer?

O principal ponto de atenção é a diferença entre licenças de desenvolvimento e de produção. Certifique‑se de que sua licença corresponde ao ambiente de implantação. Licenças temporárias são ótimas para testes, mas têm datas de expiração – não seja pego desprevenido em produção!

Como o GroupDocs se compara a outras bibliotecas PDF como iText?

O GroupDocs é mais focado em anotações e campos de formulário, enquanto o iText é uma biblioteca de propósito geral para criação e manipulação de PDFs. O GroupDocs tem uma API mais simples para tarefas de anotação, mas menos flexibilidade para geração de PDFs de baixo nível. Se o seu objetivo principal é adicionar elementos interativos a PDFs existentes, o GroupDocs costuma ser a escolha melhor.

Última atualização: 2026-08-19
Testado com: GroupDocs.Annotation 25.2
Autor: GroupDocs

Tutoriais relacionados