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