applied_patches/0502-vcl-pluggable-mtf-renderer.diff

   1 moved here from rsvg renderer
   2
   3 From:  <>
   4
   5
   6 ---
   7
   8  vcl/inc/vcl/gdimtf.hxx    |   26 +++++++++
   9  vcl/source/gdi/gdimtf.cxx |  129 +++++++++++++++++++++++++++++++++++++++++++++
  10  2 files changed, 154 insertions(+), 1 deletions(-)
  11
  12 diff --git a/vcl/inc/vcl/gdimtf.hxx b/vcl/inc/vcl/gdimtf.hxx
  13 index 234e127..6903acb 100644
  14 --- vcl/inc/vcl/gdimtf.hxx
  15 +++ vcl/inc/vcl/gdimtf.hxx
  16 @@ -41,6 +41,7 @@
  17  class OutputDevice;
  18  class ImpLabelList;
  19  class MetaAction;
  20 +class MetaCommentAction;
  21  class SvStream;
  22  class Color;
  23  class BitmapEx;
  24 @@ -140,6 +141,7 @@ private:
  25                                                        const PolyPolygon&    rPolyPoly,
  26                                                        const Gradient&          rGrad           );
  27         SAL_DLLPRIVATE bool                        ImplPlayWithRenderer( OutputDevice* pOut, const Point& rPos, Size rDestSize );
  28 +    SAL_DLLPRIVATE void          ImplDelegate2PluggableRenderer( const MetaCommentAction* pAct, OutputDevice* pOut );
  29
  30  //#endif // __PRIVATE
  31
  32 @@ -243,5 +245,29 @@ public:
  33      void           UseCanvas( BOOL _bUseCanvas );
  34  };
  35
  36 +/** Create a special metaaction that delegates rendering to specified
  37 +    service.
  38 +
  39 +    This factory function creates a MetaCommentAction that delegates
  40 +    rendering to the specified services, once played back in the
  41 +    metafile.
  42 +
  43 +    @param rRendererServiceName
  44 +    Renderer service. Gets an awt::XGraphic on instantiation
  45 +
  46 +    @param rGraphicServiceName
  47 +    Graphic service. Gets the raw data on instantiation
  48 +
  49 +    @param pData
  50 +    Raw data. Gets copied
  51 +
  52 +    @param nDataSize
  53 +    Length, in byte, of raw data
  54 + */
  55 +MetaCommentAction* makePluggableRendererAction( const rtl::OUString& rRendererServiceName,
  56 +                                                const rtl::OUString& rGraphicServiceName,
  57 +                                                const void* pData,
  58 +                                                sal_uInt32 nDataSize );
  59 +
  60  #endif // _SV_GDIMTF_HXX
  61
  62 diff --git a/vcl/source/gdi/gdimtf.cxx b/vcl/source/gdi/gdimtf.cxx
  63 index 92e2acf..8c1c012 100644
  64 --- vcl/source/gdi/gdimtf.cxx
  65 +++ vcl/source/gdi/gdimtf.cxx
  66 @@ -54,6 +54,10 @@
  67  #include <com/sun/star/rendering/MtfRenderer.hpp>
  68  #include <comphelper/processfactory.hxx>
  69  #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  70 +#include <com/sun/star/lang/XInitialization.hpp>
  71 +#include <com/sun/star/awt/XGraphics.hpp>
  72 +#include <com/sun/star/graphic/XGraphic.hpp>
  73 +#include <com/sun/star/graphic/XGraphicRenderer.hpp>
  74
  75  using namespace com::sun::star;
  76
  77 @@ -477,7 +481,16 @@ void GDIMetaFile::Play( OutputDevice* pOut, ULONG nPos )
  78                 {
  79                         if( !Hook() )
  80                         {
  81 -                               pAction->Execute( pOut );
  82 +                MetaCommentAction* pCommentAct = static_cast<MetaCommentAction*>(pAction);
  83 +                if( pAction->GetType() == META_COMMENT_ACTION &&
  84 +                    pCommentAct->GetComment().Equals("DELEGATE_PLUGGABLE_RENDERER") )
  85 +                {
  86 +                    ImplDelegate2PluggableRenderer(pCommentAct, pOut);
  87 +                }
  88 +                else
  89 +                {
  90 +                    pAction->Execute( pOut );
  91 +                }
  92
  93                                 // flush output from time to time
  94                                 if( i++ > nSyncCount )
  95 @@ -563,6 +576,77 @@ bool GDIMetaFile::ImplPlayWithRenderer( OutputDevice* pOut, const Point& rPos, S
  96
  97  // ------------------------------------------------------------------------
  98
  99 +void GDIMetaFile::ImplDelegate2PluggableRenderer( const MetaCommentAction* pAct, OutputDevice* pOut )
 100 +{
 101 +    OSL_ASSERT( pAct->GetComment().Equals("DELEGATE_PLUGGABLE_RENDERER") );
 102 +
 103 +    // read payload - string of service name, followed by raw render input
 104 +    const BYTE* pData = pAct->GetData();
 105 +    const BYTE* const pEndData = pData + pAct->GetDataSize();
 106 +    if( !pData )
 107 +        return;
 108 +
 109 +    ::rtl::OUStringBuffer aBuffer;
 110 +    while( pData<pEndData && *pData )
 111 +        aBuffer.append(static_cast<sal_Unicode>(*pData++));
 112 +    const ::rtl::OUString aRendererServiceName=aBuffer.makeStringAndClear();
 113 +    ++pData;
 114 +
 115 +    while( pData<pEndData && *pData )
 116 +        aBuffer.append(static_cast<sal_Unicode>(*pData++));
 117 +    const ::rtl::OUString aGraphicServiceName=aBuffer.makeStringAndClear();
 118 +    ++pData;
 119 +
 120 +    uno::Reference< lang::XMultiServiceFactory > xFactory = vcl::unohelper::GetMultiServiceFactory();
 121 +    if( pData<pEndData && xFactory.is() )
 122 +    {
 123 +        try
 124 +        {
 125 +            // instantiate render service
 126 +            uno::Sequence<uno::Any> aRendererArgs(1);
 127 +            aRendererArgs[0] = makeAny(uno::Reference<awt::XGraphics>(pOut->CreateUnoGraphics()));
 128 +            uno::Reference<graphic::XGraphicRenderer> xRenderer(
 129 +                xFactory->createInstanceWithArguments(
 130 +                    aRendererServiceName,
 131 +                    aRendererArgs),
 132 +                uno::UNO_QUERY );
 133 +
 134 +            // instantiate graphic service
 135 +            uno::Reference<graphic::XGraphic> xGraphic(
 136 +                xFactory->createInstance(
 137 +                    aGraphicServiceName),
 138 +                uno::UNO_QUERY );
 139 +
 140 +            uno::Reference<lang::XInitialization> xInit(
 141 +                xGraphic, uno::UNO_QUERY);
 142 +
 143 +            if(xGraphic.is() && xRenderer.is() && xInit.is())
 144 +            {
 145 +                // delay intialization of XGraphic, to only expose
 146 +                // XGraphic-generating services to arbitrary binary data
 147 +                uno::Sequence< sal_Int8 > aSeq(
 148 +                    (sal_Int8*)&pData, pEndData-pData );
 149 +                uno::Sequence<uno::Any> aGraphicsArgs(1);
 150 +                aGraphicsArgs[0] = makeAny(aSeq);
 151 +                xInit->initialize(aGraphicsArgs);
 152 +
 153 +                xRenderer->render(xGraphic);
 154 +            }
 155 +        }
 156 +        catch( uno::RuntimeException& )
 157 +        {
 158 +            // runtime errors are fatal
 159 +            throw;
 160 +        }
 161 +        catch( uno::Exception& )
 162 +        {
 163 +            // ignore errors, no way of reporting them here
 164 +        }
 165 +    }
 166 +}
 167 +
 168 +// ------------------------------------------------------------------------
 169 +
 170  void GDIMetaFile::Play( OutputDevice* pOut, const Point& rPos,
 171                                                 const Size& rSize, ULONG nPos )
 172  {
 173 @@ -2606,3 +2690,46 @@ void GDIMetaFile::UseCanvas( BOOL _bUseCanvas )
 174  {
 175      bUseCanvas = _bUseCanvas;
 176  }
 177 +
 178 +// ------------------------------------------------------------------------
 179 +
 180 +MetaCommentAction* makePluggableRendererAction( const rtl::OUString& rRendererServiceName,
 181 +                                                const rtl::OUString& rGraphicServiceName,
 182 +                                                const void* _pData,
 183 +                                                sal_uInt32 nDataSize )
 184 +{
 185 +    const BYTE* pData=(BYTE*)_pData;
 186 +
 187 +    // data gets copied twice, unfortunately
 188 +    rtl::OString aRendererServiceName(
 189 +        rRendererServiceName.getStr(),
 190 +        rRendererServiceName.getLength(),
 191 +        RTL_TEXTENCODING_ASCII_US);
 192 +    rtl::OString aGraphicServiceName(
 193 +        rGraphicServiceName.getStr(),
 194 +        rGraphicServiceName.getLength(),
 195 +        RTL_TEXTENCODING_ASCII_US);
 196 +
 197 +    std::vector<sal_uInt8> aMem(
 198 +        aRendererServiceName.getLength()+
 199 +        aGraphicServiceName.getLength()+2+nDataSize);
 200 +    sal_uInt8* pMem=&aMem[0];
 201 +
 202 +    std::copy(aRendererServiceName.getStr(),
 203 +              aRendererServiceName.getStr()+aRendererServiceName.getLength()+1,
 204 +              pMem);
 205 +    pMem+=aRendererServiceName.getLength()+1;
 206 +    std::copy(aGraphicServiceName.getStr(),
 207 +              aGraphicServiceName.getStr()+aGraphicServiceName.getLength()+1,
 208 +              pMem);
 209 +    pMem+=aGraphicServiceName.getLength()+1;
 210 +
 211 +    std::copy(pData,pData+nDataSize,
 212 +              pMem);
 213 +
 214 +    return new MetaCommentAction(
 215 +        "DELEGATE_PLUGGABLE_RENDERER",
 216 +        0,
 217 +        &aMem[0],
 218 +        aMem.size());
 219 +}