DocumentToGraphicRenderer.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#include <svtools/DocumentToGraphicRenderer.hxx>
 
#include <comphelper/propertyvalue.hxx>
#include <vcl/gdimtf.hxx>
#include <vcl/svapp.hxx>
#include <vcl/outdev.hxx>
#include <vcl/pdfextoutdevdata.hxx>
 
#include <tools/fract.hxx>
 
#include <com/sun/star/awt/XDevice.hpp>
#include <com/sun/star/awt/XToolkit.hpp>
#include <com/sun/star/text/XPageCursor.hpp>
#include <com/sun/star/text/XTextViewCursorSupplier.hpp>
#include <com/sun/star/view/XRenderable.hpp>
#include <com/sun/star/view/XSelectionSupplier.hpp>
#include <com/sun/star/beans/PropertyValues.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/drawing/XShapes.hpp>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/frame/XModel.hpp>
 
#include <toolkit/helper/vclunohelper.hxx>
 
using namespace css;
using namespace css::uno;
using namespace css::lang;
using namespace css::beans;
 
DocumentToGraphicRenderer::DocumentToGraphicRenderer( const Reference<XComponent>& rxDocument, bool bSelectionOnly ) :
    mxDocument(rxDocument),
    mxModel( mxDocument, uno::UNO_QUERY ),
    mxController( mxModel->getCurrentController() ),
    mxRenderable (mxDocument, uno::UNO_QUERY ),
    mxToolkit( VCLUnoHelper::CreateToolkit() ),
    meDocType( UNKNOWN )
{
    try
    {
        uno::Reference< lang::XServiceInfo > xServiceInfo( mxDocument, uno::UNO_QUERY);
        if (xServiceInfo.is())
        {
            if (xServiceInfo->supportsService("com.sun.star.text.TextDocument"))
                meDocType = WRITER;
            else if (xServiceInfo->supportsService("com.sun.star.sheet.SpreadsheetDocument"))
                meDocType = CALC;
            else if (xServiceInfo->supportsService("com.sun.star.presentation.PresentationDocument"))
                meDocType = IMPRESS;
            else
                meDocType = UNKNOWN;
        }
    }
    catch (const uno::Exception&)
    {
    }
 
    if (!(bSelectionOnly && mxController.is()))
        return;
 
    try
    {
        uno::Reference< view::XSelectionSupplier > xSelSup( mxController, uno::UNO_QUERY);
        if (xSelSup.is())
        {
            uno::Any aViewSelection( xSelSup->getSelection());
            if (aViewSelection.hasValue())
            {
                /* FIXME: Writer always has a selection even if nothing is
                 * selected, but passing a selection to
                 * XRenderable::render() it always renders an empty page.
                 * So disable the selection already here. The current page
                 * the cursor is on is rendered. */
                if (!isWriter())
                    maSelection = aViewSelection;
            }
        }
    }
    catch (const uno::Exception&)
    {
    }
}
 
DocumentToGraphicRenderer::~DocumentToGraphicRenderer()
{
}
 
Size DocumentToGraphicRenderer::getDocumentSizeInPixels(sal_Int32 nCurrentPage)
{
    Size aSize100mm = getDocumentSizeIn100mm(nCurrentPage);
    return Application::GetDefaultDevice()->LogicToPixel(aSize100mm, MapMode(MapUnit::Map100thMM));
}
 
bool DocumentToGraphicRenderer::hasSelection() const
{
    return maSelection.hasValue();
}
 
uno::Any DocumentToGraphicRenderer::getSelection() const
{
    uno::Any aSelection;
    if (hasSelection())
        aSelection = maSelection;
    else
        aSelection <<= mxDocument;  // default: render whole document
    return aSelection;
}
 
Size DocumentToGraphicRenderer::getDocumentSizeIn100mm(sal_Int32 nCurrentPage,
                                                       Point* pDocumentPosition, Point* pCalcPagePosition, Size* pCalcPageSize)
{
    Reference< awt::XDevice > xDevice(mxToolkit->createScreenCompatibleDevice( 32, 32 ) );
 
    uno::Any selection( getSelection());
 
    PropertyValues renderProperties{ comphelper::makePropertyValue("IsPrinter", true),
                                     comphelper::makePropertyValue("RenderDevice", xDevice),
                                     comphelper::makePropertyValue("View", mxController),
                                     comphelper::makePropertyValue("RenderToGraphic", true) };
 
    awt::Size aSize;
    awt::Size aCalcPageSize;
    awt::Point aPos;
    awt::Point aCalcPos;
 
    sal_Int32 nPages = mxRenderable->getRendererCount( selection, renderProperties );
    if (nPages >= nCurrentPage)
    {
        const Sequence< beans::PropertyValue > aResult = mxRenderable->getRenderer(nCurrentPage - 1, selection, renderProperties );
        for( const auto& rProperty : aResult )
        {
            if ( rProperty.Name == "PageSize" )
            {
                rProperty.Value >>= aSize;
            }
            else if (rProperty.Name == "PagePos")
            {
                rProperty.Value >>= aPos;
            }
            else if (rProperty.Name == "CalcPagePos")
            {
                rProperty.Value >>= aCalcPos;
            }
            else if (rProperty.Name == "CalcPageContentSize")
            {
                rProperty.Value >>= aCalcPageSize;
            }
        }
    }
 
    if (pDocumentPosition)
    {
        *pDocumentPosition = Point(aPos.X, aPos.Y);
    }
    if (pCalcPagePosition)
    {
        *pCalcPagePosition = Point(aCalcPos.X, aCalcPos.Y);
    }
    if (pCalcPageSize)
    {
        *pCalcPageSize = Size(aCalcPageSize.Width, aCalcPageSize.Height);
    }
 
    return Size( aSize.Width, aSize.Height );
}
 
Graphic DocumentToGraphicRenderer::renderToGraphic(
    sal_Int32 nCurrentPage,
    Size aDocumentSizePixel,
    Size aTargetSizePixel,
    Color aPageColor,
    bool bExtOutDevData)
 
{
    if (!mxModel.is() || !mxController.is() || !mxRenderable.is())
        return Graphic();
 
    Reference< awt::XDevice > xDevice(mxToolkit->createScreenCompatibleDevice( aTargetSizePixel.Width(), aTargetSizePixel.Height() ) );
    if (!xDevice.is())
        return Graphic();
 
    assert( !aDocumentSizePixel.IsEmpty() && !aTargetSizePixel.IsEmpty());
 
    double fScaleX = aTargetSizePixel.Width()  / static_cast<double>(aDocumentSizePixel.Width());
    double fScaleY = aTargetSizePixel.Height() / static_cast<double>(aDocumentSizePixel.Height());
 
    PropertyValues renderProps{
        comphelper::makePropertyValue("IsPrinter", true),
        comphelper::makePropertyValue("RenderDevice", xDevice),
        comphelper::makePropertyValue("View", mxController),
        comphelper::makePropertyValue("RenderToGraphic", true),
        comphelper::makePropertyValue("HasPDFExtOutDevData", bExtOutDevData),
        comphelper::makePropertyValue("PageRange", OUString::number(nCurrentPage))
    };
 
    GDIMetaFile aMtf;
 
    OutputDevice* pOutputDev = VCLUnoHelper::GetOutputDevice( xDevice );
 
    vcl::PDFExtOutDevData aPDFExtOutDevData(*pOutputDev);
    if (bExtOutDevData)
    {
        aPDFExtOutDevData.SetIsExportBookmarks(true);
        pOutputDev->SetExtOutDevData(&aPDFExtOutDevData);
    }
 
    pOutputDev->SetAntialiasing(pOutputDev->GetAntialiasing() | AntialiasingFlags::Enable);
    MapMode mm = pOutputDev->GetMapMode();
    mm.SetScaleX( Fraction(fScaleX) );
    mm.SetScaleY( Fraction(fScaleY) );
    pOutputDev->SetMapMode( mm );
 
    aMtf.Record( pOutputDev );
 
    if (aPageColor != COL_TRANSPARENT)
    {
        pOutputDev->SetBackground(Wallpaper(aPageColor));
        pOutputDev->Erase();
    }
 
    uno::Any aSelection( getSelection());
    mxRenderable->render(nCurrentPage - 1, aSelection, renderProps );
 
    aMtf.Stop();
    aMtf.WindStart();
    aMtf.SetPrefSize( aTargetSizePixel );
 
    if (bExtOutDevData)
        maChapterNames = aPDFExtOutDevData.GetChapterNames();
 
    return Graphic(aMtf);
}
 
const std::vector<OUString>& DocumentToGraphicRenderer::getChapterNames() const
{
    return maChapterNames;
}
 
sal_Int32 DocumentToGraphicRenderer::getCurrentPage()
{
    if (hasSelection())
        return 1;
 
    if (isWriter())
        return getCurrentPageWriter();
 
    /* TODO: other application specific page detection? */
    return 1;
}
 
sal_Int32 DocumentToGraphicRenderer::getPageCount()
{
    Reference< awt::XDevice > xDevice(mxToolkit->createScreenCompatibleDevice( 32, 32 ) );
 
    uno::Any selection( getSelection() );
 
    PropertyValues renderProperties{ comphelper::makePropertyValue("IsPrinter", true),
                                     comphelper::makePropertyValue("RenderDevice", xDevice),
                                     comphelper::makePropertyValue("View", mxController),
                                     comphelper::makePropertyValue("RenderToGraphic", true) };
 
    sal_Int32 nPages = mxRenderable->getRendererCount( selection, renderProperties );
 
    return nPages;
}
 
sal_Int32 DocumentToGraphicRenderer::getCurrentPageWriter()
{
    Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(mxModel->getCurrentController(), UNO_QUERY);
    if (!xTextViewCursorSupplier.is())
        return 1;
    Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), UNO_QUERY);
    return xCursor.is() ? xCursor->getPage() : 1;
}
 
// static
bool DocumentToGraphicRenderer::isShapeSelected(
        css::uno::Reference< css::drawing::XShapes > & rxShapes,
        css::uno::Reference< css::drawing::XShape > & rxShape,
        const css::uno::Reference< css::frame::XController > & rxController )
{
    bool bShape = false;
    if (rxController.is())
    {
        uno::Reference< view::XSelectionSupplier > xSelectionSupplier( rxController, uno::UNO_QUERY);
        if (xSelectionSupplier.is())
        {
            uno::Any aAny( xSelectionSupplier->getSelection());
            if (aAny >>= rxShapes)
                bShape = true;
            else if (aAny >>= rxShape)
                bShape = true;
        }
    }
    return bShape;
}
 
bool DocumentToGraphicRenderer::isWriter() const
{
    if (meDocType == WRITER)
        return true;
    else
        return false;
}
 
bool DocumentToGraphicRenderer::isCalc() const
{
    if (meDocType == CALC)
        return true;
    else
        return false;
}
 
bool DocumentToGraphicRenderer::isImpress() const
{
    if (meDocType == IMPRESS)
        return true;
    else
        return false;
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */