sfx2/source/doc/graphhelp.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
  21 #ifdef _WIN32
  22 #include <prewin.h>
  23 #include <postwin.h>
  24 #endif
  25
  26 #include <com/sun/star/uno/Exception.hpp>
  27 #include <com/sun/star/graphic/GraphicProvider.hpp>
  28 #include <com/sun/star/graphic/XGraphicProvider.hpp>
  29 #include <com/sun/star/graphic/XGraphic.hpp>
  30
  31
  32 #include <vcl/gdimtf.hxx>
  33 #include <vcl/graph.hxx>
  34 #include <vcl/cvtgrf.hxx>
  35 #include <vcl/bitmapex.hxx>
  36 #include <vcl/graphicfilter.hxx>
  37
  38 #include <tools/stream.hxx>
  39 #include <unotools/ucbstreamhelper.hxx>
  40 #include <comphelper/processfactory.hxx>
  41 #include <comphelper/propertyvalue.hxx>
  42 #include <o3tl/char16_t2wchar_t.hxx>
  43 #include <o3tl/string_view.hxx>
  44
  45 #include "graphhelp.hxx"
  46 #include <bitmaps.hlst>
  47
  48 #include <memory>
  49
  50 #if defined _WIN32
  51 #include <unotools/tempfile.hxx>
  52 #include <vcl/outdev.hxx>
  53 #endif
  54
  55 using namespace css;
  56
  57 std::unique_ptr<SvMemoryStream> GraphicHelper::getFormatStrFromGDI_Impl( const GDIMetaFile* pGDIMeta, ConvertDataFormat nFormat )
  58 {
  59     std::unique_ptr<SvMemoryStream> pResult;
  60     if ( pGDIMeta )
  61     {
  62         std::unique_ptr<SvMemoryStream> pStream(new SvMemoryStream( 65535, 65535 ));
  63         Graphic aGraph( *pGDIMeta );
  64         if ( GraphicConverter::Export( *pStream, aGraph, nFormat ) == ERRCODE_NONE )
  65             pResult = std::move(pStream);
  66     }
  67
  68     return pResult;
  69 }
  70
  71
  72 // static
  73 void* GraphicHelper::getEnhMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta )
  74 {
  75     void* pResult = nullptr;
  76
  77 #ifdef _WIN32
  78     if ( pGDIMeta )
  79     {
  80         OUString const aStr(".emf");
  81         ::utl::TempFile aTempFile( OUString(), true, &aStr );
  82
  83         OUString aMetaFile = aTempFile.GetFileName();
  84         OUString aMetaURL = aTempFile.GetURL();
  85
  86         std::unique_ptr<SvStream> pStream = ::utl::UcbStreamHelper::CreateStream( aMetaURL, StreamMode::STD_READWRITE );
  87         if ( pStream )
  88         {
  89             Graphic aGraph( *pGDIMeta );
  90             ErrCode nFailed = GraphicConverter::Export( *pStream, aGraph, ConvertDataFormat::EMF );
  91             pStream->Flush();
  92             pStream.reset();
  93
  94             if ( !nFailed )
  95                 pResult = GetEnhMetaFileW( o3tl::toW(aMetaFile.getStr()) );
  96         }
  97     }
  98 #else
  99     (void)pGDIMeta;  // unused
 100 #endif
 101
 102     return pResult;
 103 }
 104
 105
 106 // static
 107 void* GraphicHelper::getWinMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta, const Size& aMetaSize )
 108 {
 109     void* pResult = nullptr;
 110
 111 #ifdef _WIN32
 112     if ( pGDIMeta )
 113     {
 114         SvMemoryStream pStream( 65535, 65535 );
 115         Graphic aGraph( *pGDIMeta );
 116         ErrCode nFailed = GraphicConverter::Export( pStream, aGraph, ConvertDataFormat::WMF );
 117         pStream.Flush();
 118         if ( !nFailed )
 119         {
 120             sal_Int32 nLength = pStream.TellEnd();
 121             if ( nLength > 22 )
 122             {
 123                 HMETAFILE hMeta = SetMetaFileBitsEx( nLength - 22,
 124                                 static_cast< const unsigned char*>( pStream.GetData() ) + 22 );
 125
 126                 if ( hMeta )
 127                 {
 128                     HGLOBAL hMemory = GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, sizeof( METAFILEPICT ) );
 129
 130                     if ( hMemory )
 131                     {
 132                         METAFILEPICT* pMF = static_cast<METAFILEPICT*>(GlobalLock( hMemory ));
 133
 134                         pMF->hMF = hMeta;
 135                         pMF->mm = MM_ANISOTROPIC;
 136
 137                         MapMode aWinMode( MapUnit::Map100thMM );
 138
 139                         if ( aWinMode == pGDIMeta->GetPrefMapMode() )
 140                         {
 141                             pMF->xExt = aMetaSize.Width();
 142                             pMF->yExt = aMetaSize.Height();
 143                         }
 144                         else
 145                         {
 146                             Size aWinSize = OutputDevice::LogicToLogic( Size( aMetaSize.Width(), aMetaSize.Height() ),
 147                                                                         pGDIMeta->GetPrefMapMode(),
 148                                                                         aWinMode );
 149                             pMF->xExt = aWinSize.Width();
 150                             pMF->yExt = aWinSize.Height();
 151                         }
 152
 153                         GlobalUnlock( hMemory );
 154                         pResult = static_cast<void*>(hMemory);
 155                     }
 156                     else
 157                            DeleteMetaFile( hMeta );
 158                 }
 159             }
 160         }
 161     }
 162 #else
 163     (void)pGDIMeta;  // unused
 164     (void)aMetaSize; // unused
 165 #endif
 166
 167
 168     return pResult;
 169 }
 170
 171
 172 // static
 173 bool GraphicHelper::getThumbnailFormatFromGDI_Impl(GDIMetaFile const * pMetaFile, const uno::Reference<io::XStream>& xStream)
 174 {
 175     bool bResult = false;
 176
 177     if (!pMetaFile || !xStream.is())
 178         return false;
 179
 180     std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(xStream));
 181
 182     if (pStream->GetError())
 183         return false;
 184
 185     BitmapEx aResultBitmap;
 186
 187     bResult = pMetaFile->CreateThumbnail(aResultBitmap, BmpConversion::N8BitColors, BmpScaleFlag::Default);
 188
 189     if (!bResult || aResultBitmap.IsEmpty())
 190         return false;
 191
 192     GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
 193
 194     if (rFilter.compressAsPNG(aResultBitmap, *pStream) != ERRCODE_NONE)
 195         return false;
 196
 197     pStream->Flush();
 198
 199     return !pStream->GetError();
 200 }
 201
 202 // static
 203 bool GraphicHelper::getThumbnailReplacement_Impl(std::u16string_view rResID, const uno::Reference< io::XStream >& xStream )
 204 {
 205     bool bResult = false;
 206     if (!rResID.empty() && xStream.is())
 207     {
 208         uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 209         try
 210         {
 211             uno::Reference< graphic::XGraphicProvider > xGraphProvider(graphic::GraphicProvider::create(xContext));
 212             const OUString aURL{OUString::Concat("private:graphicrepository/") + rResID};
 213
 214             uno::Sequence< beans::PropertyValue > aMediaProps{ comphelper::makePropertyValue("URL",
 215                                                                                              aURL) };
 216
 217             uno::Reference< graphic::XGraphic > xGraphic = xGraphProvider->queryGraphic( aMediaProps );
 218             if ( xGraphic.is() )
 219             {
 220                 uno::Sequence< beans::PropertyValue > aStoreProps{
 221                     comphelper::makePropertyValue("OutputStream", xStream),
 222                     comphelper::makePropertyValue("MimeType", OUString("image/png"))
 223                 };
 224
 225                 xGraphProvider->storeGraphic( xGraphic, aStoreProps );
 226                 bResult = true;
 227             }
 228         }
 229         catch(const uno::Exception&)
 230         {
 231         }
 232     }
 233
 234     return bResult;
 235 }
 236
 237 // static
 238 OUString GraphicHelper::getThumbnailReplacementIDByFactoryName_Impl( std::u16string_view aFactoryShortName )
 239 {
 240     OUString sResult;
 241
 242     if ( aFactoryShortName == u"scalc" )
 243     {
 244         sResult = BMP_128X128_CALC_DOC;
 245     }
 246     else if ( aFactoryShortName == u"sdraw" )
 247     {
 248         sResult = BMP_128X128_DRAW_DOC;
 249     }
 250     else if ( aFactoryShortName == u"simpress" )
 251     {
 252         sResult = BMP_128X128_IMPRESS_DOC;
 253     }
 254     else if ( aFactoryShortName == u"smath" )
 255     {
 256         sResult = BMP_128X128_MATH_DOC;
 257     }
 258     else if ( aFactoryShortName == u"swriter" || o3tl::starts_with(aFactoryShortName, u"swriter/") )
 259     {
 260         sResult = BMP_128X128_WRITER_DOC;
 261     }
 262
 263     return sResult;
 264 }
 265
 266 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */