Gerenciar OLE em Apresentações usando Python

Sobre o que é esta página

Otimize o gerenciamento de objetos OLE no PowerPoint e em arquivos OpenDocument com Aspose.Slides para Python via .NET. Incorpore, atualize e exporte conteúdo OLE de forma contínua.

Introdução

Note

OLE (Object Linking & Embedding) é uma tecnologia da Microsoft que permite que dados e objetos criados em um aplicativo sejam vinculados ou incorporados em outro.

Por exemplo, um gráfico criado no Microsoft Excel e inserido em um slide do PowerPoint é um objeto OLE.

Um objeto OLE pode aparecer como um ícone. Clicar duas vezes no ícone abre o objeto em seu aplicativo associado (ex.: Excel) ou solicita que você escolha um aplicativo para abrir ou editar.
Um objeto OLE pode exibir seu conteúdo (por exemplo, um gráfico). Nesse caso, o PowerPoint ativa o objeto incorporado, carrega a interface do gráfico e permite que você edite os dados do gráfico dentro do PowerPoint.

Aspose.Slides for Python permite inserir objetos OLE em slides como quadros de objeto OLE (OleObjectFrame).

Adicionar objetos OLE a slides

Se você já criou um gráfico no Microsoft Excel e deseja incorporá‑lo em um slide como um quadro de objeto OLE usando o Aspose.Slides for Python, siga estas etapas:

Crie uma instância da classe Presentation.
Obtenha uma referência ao slide pelo seu índice.
Leia o arquivo Excel em um array de bytes.
Adicione um OleObjectFrame ao slide, fornecendo o array de bytes e outros detalhes do objeto OLE.
Salve a apresentação modificada como um arquivo PPTX.

No exemplo abaixo, um gráfico de um arquivo Excel é incorporado em um slide como um OleObjectFrame.

Nota: O construtor OleEmbeddedDataInfo recebe a extensão de arquivo do objeto incorporável como seu segundo parâmetro. O PowerPoint usa essa extensão para identificar o tipo de arquivo e selecionar o aplicativo adequado para abrir o objeto OLE.

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide_size = presentation.slide_size.size
    slide = presentation.slides[0]

    # Prepare os dados para o objeto OLE.
    with open("book.xlsx", "rb") as file_stream:
        file_data = file_stream.read()
        data_info = slides.dom.ole.OleEmbeddedDataInfo(file_data, "xlsx")

    # Adicione um quadro de objeto OLE ao slide.
    ole_frame = slide.shapes.add_ole_object_frame(0, 0, slide_size.width, slide_size.height, data_info)

    presentation.save("output.pptx", slides.export.SaveFormat.PPTX)

Adicionar objetos OLE vinculados

Aspose.Slides for Python permite adicionar um OleObjectFrame que vincula a um arquivo em vez de incorporar seus dados.

O exemplo Python a seguir mostra como adicionar um OleObjectFrame vinculado a um arquivo Excel em um slide:

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    # Adicione um quadro de objeto OLE com um arquivo Excel vinculado.
    slide.shapes.add_ole_object_frame(20, 20, 200, 150, "Excel.Sheet.12", "book.xlsx")

    presentation.save("output.pptx", slides.export.SaveFormat.PPTX)

Acessar objetos OLE

Se um objeto OLE já estiver incorporado em um slide, você pode acessá‑lo da seguinte forma:

Carregue a apresentação que contém o objeto OLE incorporado criando uma instância da classe Presentation.
Obtenha uma referência ao slide pelo seu índice.
Acesse a forma OleObjectFrame.
Depois de obter o quadro de objeto OLE, execute as operações necessárias nele.

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes[0]

    if isinstance(shape, slides.OleObjectFrame):
        ole_frame = shape

        # Obtenha os dados do arquivo incorporado.
        file_data = ole_frame.embedded_data.embedded_file_data

        # Obtenha a extensão do arquivo incorporado.
        file_extension = ole_frame.embedded_data.embedded_file_extension

        # ...

Acessar propriedades de objeto OLE vinculado

Aspose.Slides permite acessar as propriedades de um quadro de objeto OLE vinculado.

O exemplo Python abaixo verifica se um objeto OLE está vinculado e, se estiver, recupera o caminho para o arquivo vinculado:

import aspose.slides as slides

with slides.Presentation("sample.ppt") as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes[0]

    if isinstance(shape, slides.OleObjectFrame):
        ole_frame = shape

        # Verifique se o objeto OLE está vinculado.
        if ole_frame.is_object_link:
            # Imprima o caminho completo para o arquivo vinculado.
            print("OLE object frame is linked to:", ole_frame.link_path_long)

            # Imprima o caminho relativo para o arquivo vinculado, se presente.
            # Apenas apresentações .ppt podem conter um caminho relativo.
            if ole_frame.link_path_relative:
                print("OLE object frame relative path:", ole_frame.link_path_relative)

Alterar dados do objeto OLE

Note

Nesta seção, o exemplo de código abaixo usa Aspose.Cells for Python via .NET.

Se um objeto OLE já estiver incorporado em um slide, você pode acessá‑lo e modificar seus dados da seguinte forma:

Carregue a apresentação criando uma instância da classe Presentation.
Obtenha o slide de destino pelo seu índice.
Acesse a forma OleObjectFrame.
Depois de obter o quadro de objeto OLE, execute as operações necessárias nele.
Crie um objeto Workbook e leia os dados OLE.
Abra a Worksheet desejada e edite os dados.
Salve o Workbook atualizado em um stream.
Substitua os dados do objeto OLE usando esse stream.

No exemplo abaixo, um quadro de objeto OLE (um gráfico Excel incorporado) é acessado e seus dados de arquivo são modificados para atualizar o gráfico. O exemplo usa um PPTX criado anteriormente que contém uma única forma no primeiro slide.

import io
import aspose.slides as slides
import aspose.cells as cells

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes[0]

    if isinstance(shape, slides.OleObjectFrame):
        ole_frame = shape

        with io.BytesIO(ole_frame.embedded_data.embedded_file_data) as ole_stream:
            # Leia os dados do objeto OLE como um objeto Workbook.
            workbook = cells.Workbook(ole_stream)

        with io.BytesIO() as new_ole_stream:
            # Modifique os dados da planilha de trabalho.
            workbook.worksheets.get(0).cells.get(0, 4).put_value("E")
            workbook.worksheets.get(0).cells.get(1, 4).put_value(12)
            workbook.worksheets.get(0).cells.get(2, 4).put_value(14)
            workbook.worksheets.get(0).cells.get(3, 4).put_value(15)

            file_options = cells.OoxmlSaveOptions(cells.SaveFormat.XLSX)
            workbook.save(new_ole_stream, file_options)

            # Altere os dados do objeto do quadro OLE.
            new_data = slides.dom.ole.OleEmbeddedDataInfo(new_ole_stream.getvalue(), ole_frame.embedded_data.embedded_file_extension)
            ole_frame.set_embedded_data(new_data)

    presentation.save("output.pptx", slides.export.SaveFormat.PPTX)

Incorporar arquivos em slides

Além de gráficos Excel, o Aspose.Slides for Python permite incorporar outros tipos de arquivo em slides. Por exemplo, você pode inserir arquivos HTML, PDF e ZIP como objetos. Quando um usuário clica duas vezes em um objeto inserido, ele é aberto automaticamente no aplicativo associado, ou o usuário é solicitado a escolher um programa adequado.

Este código Python mostra como incorporar arquivos HTML e ZIP em um slide:

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    with open("sample.html", "rb") as html_stream:
        html_data = html_stream.read()

    html_data_info = slides.dom.ole.OleEmbeddedDataInfo(html_data, "html")
    html_ole_frame = slide.shapes.add_ole_object_frame(150, 120, 50, 50, html_data_info)
    html_ole_frame.is_object_icon = True

    with open("sample.zip", "rb") as zip_stream:
        zip_data = zip_stream.read()

    zip_data_info = slides.dom.ole.OleEmbeddedDataInfo(zip_data, "zip")
    zip_ole_frame = slide.shapes.add_ole_object_frame(150, 220, 50, 50, zip_data_info)
    zip_ole_frame.is_object_icon = True

    presentation.save("output.pptx", slides.export.SaveFormat.PPTX)

Definir tipos de arquivo para objetos incorporados

Ao trabalhar com apresentações, pode ser necessário substituir objetos OLE antigos por novos ou trocar um objeto OLE não suportado por um suportado. O Aspose.Slides for Python permite definir o tipo de arquivo de um objeto incorporado, permitindo atualizar os dados do quadro OLE ou sua extensão de arquivo.

Este código Python mostra como definir o tipo de arquivo do objeto OLE incorporado para zip:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]
    ole_frame = slide.shapes[0]

    file_extension = ole_frame.embedded_data.embedded_file_extension
    file_data = ole_frame.embedded_data.embedded_file_data

    print(f"Current embedded file extension is: {file_extension}")

    # Alterar o tipo de arquivo para ZIP.
    ole_frame.set_embedded_data(slides.dom.ole.OleEmbeddedDataInfo(file_data, "zip"))

    presentation.save("output.pptx", slides.export.SaveFormat.PPTX)

Definir imagens de ícone e títulos para objetos incorporados

Após incorporar um objeto OLE, uma pré‑visualização baseada em ícone é adicionada automaticamente. Essa pré‑visualização é o que os usuários veem antes de acessar ou abrir o objeto OLE. Se desejar usar uma imagem e texto específicos na pré‑visualização, você pode definir a imagem do ícone e o título usando o Aspose.Slides for Python.

Este código Python mostra como definir a imagem do ícone e o título para um objeto incorporado:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]
    ole_frame = slide.shapes[0]

    # Adicione uma imagem aos recursos da apresentação.
    with slides.Images.from_file("image.png") as image:
        ole_image = presentation.images.add_image(image)

    # Defina um título e a imagem para a pré-visualização OLE.
    ole_frame.substitute_picture_title = "My title"
    ole_frame.substitute_picture_format.picture.image = ole_image
    ole_frame.is_object_icon = True

    presentation.save("output.pptx", slides.export.SaveFormat.PPTX)

Impedir que quadros de objeto OLE sejam redimensionados e reposicionados

Após adicionar um objeto OLE vinculado a um slide, o PowerPoint pode solicitar que você atualize os links ao abrir a apresentação. Selecionar Atualizar Links pode mudar o tamanho e a posição do quadro do objeto OLE porque o PowerPoint atualiza a pré‑visualização com os dados do objeto vinculado. Para impedir que o PowerPoint solicite a atualização dos dados do objeto, defina a propriedade update_automatic da classe OleObjectFrame como False:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]
    ole_frame = slide.shapes[0]

    ole_frame.update_automatic = False

    presentation.save("output.pptx", slides.export.SaveFormat.PPTX)

Extrair arquivos incorporados

Aspose.Slides for Python permite extrair arquivos incorporados em slides como objetos OLE da seguinte forma:

Crie uma instância da classe Presentation que contém os objetos OLE que você deseja extrair.
Itere por todas as formas na apresentação e localize as formas OLEObjectFrame.
Recupere os dados de arquivo incorporados de cada OLEObjectFrame e grave‑os no disco.

O código Python a seguir mostra como extrair arquivos incorporados em um slide como objetos OLE:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]

    for index, shape in enumerate(slide.shapes):
        if isinstance(shape, slides.OleObjectFrame):
            ole_frame = shape

            file_data = ole_frame.embedded_data.embedded_file_data
            file_extension = ole_frame.embedded_data.embedded_file_extension

            file_path = f"OLE_object_{index}{file_extension}"
            with open(file_path, 'wb') as file_stream:
                file_stream.write(file_data)

Perguntas Frequentes

O conteúdo OLE será renderizado ao exportar slides para PDF/imagens?

O que está visível no slide é renderizado — o ícone/imagem de substituição (pré‑visualização). O conteúdo OLE “vivo” não é executado durante a renderização. Se necessário, defina sua própria imagem de pré‑visualização para garantir a aparência esperada no PDF exportado.

Para também preservar o arquivo incorporado como um anexo PDF, defina PdfOptions.include_ole_data como True. Esta opção está desativada por padrão. Para um exemplo e instruções de como verificar o anexo, veja Preservar arquivos OLE incorporados como anexos PDF.

Como posso bloquear um objeto OLE em um slide para que os usuários não possam mover/editar no PowerPoint?

Bloqueie a forma: o Aspose.Slides fornece travas em nível de forma. Isso não é criptografia, mas impede efetivamente edições e movimentações acidentais.

Por que um objeto Excel vinculado “salta” ou muda de tamanho ao abrir a apresentação?

O PowerPoint pode atualizar a pré‑visualização do OLE vinculado. Para uma aparência estável, siga as práticas da Solução de Redimensionamento de Worksheet — ajuste o quadro ao intervalo ou escale o intervalo para um quadro fixo e defina uma imagem de substituição apropriada.

Os caminhos relativos para objetos OLE vinculados serão preservados no formato PPTX?

No PPTX, as informações de “caminho relativo” não estão disponíveis — apenas o caminho completo. Caminhos relativos são encontrados no formato PPT mais antigo. Para portabilidade, prefira caminhos absolutos confiáveis/URIs acessíveis ou incorporação.

Gerenciar Arquivos de Mídia Gerenciar Texto em Apresentações com Python