filter/source/graphic/GraphicExportFilter.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "GraphicExportFilter.hxx"
  21
  22 #include <com/sun/star/drawing/GraphicExportFilter.hpp>
  23 #include <com/sun/star/drawing/XShape.hpp>
  24 #include <com/sun/star/drawing/XShapes.hpp>
  25 #include <com/sun/star/frame/XModel.hpp>
  26
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <vcl/graphicfilter.hxx>
  29 #include <svl/outstrm.hxx>
  30 #include <svtools/DocumentToGraphicRenderer.hxx>
  31
  32 using namespace css;
  33
  34 GraphicExportFilter::GraphicExportFilter( const uno::Reference< uno::XComponentContext > & rxContext  )
  35     : mxContext(rxContext)
  36     , mnTargetWidth(0)
  37     , mnTargetHeight(0)
  38     , mbSelectionOnly(false)
  39 {}
  40
  41 GraphicExportFilter::~GraphicExportFilter()
  42 {}
  43
  44 //  XServiceInfo
  45 sal_Bool GraphicExportFilter::supportsService(const OUString& sServiceName)
  46 {
  47     return cppu::supportsService(this, sServiceName);
  48 }
  49 OUString GraphicExportFilter::getImplementationName()
  50 {
  51     return "com.sun.star.comp.GraphicExportFilter";
  52 }
  53 css::uno::Sequence< OUString > GraphicExportFilter::getSupportedServiceNames()
  54 {
  55     return { "com.sun.star.document.ExportFilter" };
  56 }
  57
  58 void GraphicExportFilter::gatherProperties( const uno::Sequence< beans::PropertyValue > & rProperties )
  59 {
  60     OUString aInternalFilterName;
  61
  62     for ( const beans::PropertyValue& rProperty : rProperties )
  63     {
  64         if ( rProperty.Name == "FilterName" )
  65         {
  66             rProperty.Value >>= aInternalFilterName;
  67             const sal_Int32 nLen = aInternalFilterName.getLength();
  68             aInternalFilterName = aInternalFilterName.replaceFirst("calc_", "");
  69             if (aInternalFilterName.getLength() == nLen)
  70                 aInternalFilterName = aInternalFilterName.replaceFirst("writer_", "");
  71             if (aInternalFilterName.getLength() == nLen)
  72                 aInternalFilterName = aInternalFilterName.replaceFirst("web_", "");
  73             if (aInternalFilterName.getLength() == nLen)
  74                 aInternalFilterName = aInternalFilterName.replaceFirst("draw_", "");
  75             if (aInternalFilterName.getLength() == nLen)
  76                 aInternalFilterName = aInternalFilterName.replaceFirst("impress_", "");
  77         }
  78         else if ( rProperty.Name == "FilterData" )
  79         {
  80             rProperty.Value >>= maFilterDataSequence;
  81         }
  82         else if ( rProperty.Name == "OutputStream" )
  83         {
  84             rProperty.Value >>= mxOutputStream;
  85         }
  86         else if ( rProperty.Name == "SelectionOnly" )
  87         {
  88             rProperty.Value >>= mbSelectionOnly;
  89         }
  90     }
  91
  92     for ( const beans::PropertyValue& rProp : std::as_const(maFilterDataSequence) )
  93     {
  94         if ( rProp.Name == "PixelWidth" )
  95         {
  96             rProp.Value >>= mnTargetWidth;
  97         }
  98         else if ( rProp.Name == "PixelHeight" )
  99         {
 100             rProp.Value >>= mnTargetHeight;
 101         }
 102     }
 103
 104     if ( aInternalFilterName.isEmpty() )
 105         return;
 106
 107     GraphicFilter aGraphicFilter( true );
 108
 109     sal_uInt16 nFilterCount = aGraphicFilter.GetExportFormatCount();
 110     sal_uInt16 nFormat;
 111
 112     for ( nFormat = 0; nFormat < nFilterCount; nFormat++ )
 113     {
 114         if ( aGraphicFilter.GetExportInternalFilterName( nFormat ) == aInternalFilterName )
 115             break;
 116     }
 117     if ( nFormat < nFilterCount )
 118     {
 119         maFilterExtension = aGraphicFilter.GetExportFormatShortName( nFormat );
 120     }
 121 }
 122
 123 sal_Bool SAL_CALL GraphicExportFilter::filter( const uno::Sequence< beans::PropertyValue > & rDescriptor )
 124 {
 125     gatherProperties(rDescriptor);
 126
 127     if (mbSelectionOnly && mxDocument.is())
 128     {
 129         uno::Reference< frame::XModel > xModel( mxDocument, uno::UNO_QUERY);
 130         if (xModel.is())
 131         {
 132             uno::Reference< frame::XController > xController( xModel->getCurrentController());
 133             if (xController.is())
 134             {
 135                 uno::Reference< drawing::XShapes > xShapes;
 136                 uno::Reference< drawing::XShape > xShape;
 137                 if (DocumentToGraphicRenderer::isShapeSelected( xShapes, xShape, xController))
 138                     return filterExportShape( rDescriptor, xShapes, xShape);
 139             }
 140         }
 141     }
 142
 143     return filterRenderDocument();
 144 }
 145
 146 bool GraphicExportFilter::filterRenderDocument() const
 147 {
 148     DocumentToGraphicRenderer aRenderer( mxDocument, mbSelectionOnly );
 149     sal_Int32 nCurrentPage = aRenderer.getCurrentPage();
 150     Size aDocumentSizePixel = aRenderer.getDocumentSizeInPixels(nCurrentPage);
 151
 152     Size aTargetSizePixel(mnTargetWidth, mnTargetHeight);
 153
 154     if (mnTargetWidth == 0 || mnTargetHeight == 0)
 155         aTargetSizePixel = aDocumentSizePixel;
 156
 157     Graphic aGraphic = aRenderer.renderToGraphic(nCurrentPage, aDocumentSizePixel, aTargetSizePixel, COL_WHITE, /*bExtOutDevData=*/false);
 158
 159     GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
 160
 161     sal_uInt16 nFilterFormat = rFilter.GetExportFormatNumberForShortName( maFilterExtension );
 162
 163     SvMemoryStream aMemStream;
 164     const GraphicConversionParameters aParameters(aTargetSizePixel, true, true);
 165
 166     const ErrCode nResult = rFilter.ExportGraphic( aGraphic.GetBitmapEx(aParameters), OUString(), aMemStream,
 167             nFilterFormat, &maFilterDataSequence );
 168
 169     if ( nResult == ERRCODE_NONE )
 170     {
 171         SvOutputStream aOutputStream( mxOutputStream );
 172         aMemStream.Seek(0);
 173         aOutputStream.WriteStream( aMemStream );
 174
 175         return true;
 176     }
 177
 178     return false;
 179 }
 180
 181 bool GraphicExportFilter::filterExportShape(
 182         const css::uno::Sequence< css::beans::PropertyValue > & rDescriptor,
 183         const css::uno::Reference< css::drawing::XShapes > & rxShapes,
 184         const css::uno::Reference< css::drawing::XShape > & rxShape ) const
 185 {
 186     uno::Reference< lang::XComponent > xSourceDoc;
 187     if (rxShapes.is())
 188         xSourceDoc.set( rxShapes, uno::UNO_QUERY_THROW );
 189     else if (rxShape.is())
 190         xSourceDoc.set( rxShape, uno::UNO_QUERY_THROW );
 191     if (!xSourceDoc.is())
 192         return false;
 193
 194     uno::Reference< drawing::XGraphicExportFilter > xGraphicExporter =
 195         drawing::GraphicExportFilter::create( mxContext );
 196     if (!xGraphicExporter.is())
 197         return false;
 198
 199     // Need to replace the internal filter name with the short name
 200     // (extension).
 201     uno::Sequence< beans::PropertyValue > aDescriptor( rDescriptor);
 202     for (sal_Int32 i = 0; i < aDescriptor.getLength(); ++i)
 203     {
 204         if (aDescriptor[i].Name == "FilterName")
 205         {
 206             aDescriptor[i].Value <<= maFilterExtension;
 207             break;
 208         }
 209     }
 210
 211     xGraphicExporter->setSourceDocument( xSourceDoc );
 212     return xGraphicExporter->filter( aDescriptor );
 213 }
 214
 215 void SAL_CALL GraphicExportFilter::cancel( )
 216 {
 217 }
 218
 219 void SAL_CALL GraphicExportFilter::setSourceDocument( const uno::Reference< lang::XComponent > & xDocument )
 220 {
 221     mxDocument = xDocument;
 222 }
 223
 224 void SAL_CALL GraphicExportFilter::initialize( const uno::Sequence< uno::Any > & )
 225 {
 226 }
 227
 228 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 229 filter_GraphicExportFilter_get_implementation(
 230     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
 231 {
 232     return cppu::acquire(new GraphicExportFilter(context));
 233 }
 234 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */