oox/source/drawingml/misccontexts.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 <drawingml/misccontexts.hxx>
  21 #include <oox/helper/attributelist.hxx>
  22 #include <oox/helper/graphichelper.hxx>
  23 #include <oox/core/xmlfilterbase.hxx>
  24 #include <oox/drawingml/drawingmltypes.hxx>
  25 #include <drawingml/fillproperties.hxx>
  26 #include <oox/token/namespaces.hxx>
  27 #include <oox/token/tokens.hxx>
  28 #include <vcl/GraphicExternalLink.hxx>
  29 #include <vcl/graph.hxx>
  30 #include <unordered_map>
  31 #include <frozen/bits/defines.h>
  32 #include <frozen/bits/elsa_std.h>
  33 #include <frozen/unordered_map.h>
  34
  35 using namespace ::com::sun::star;
  36 using namespace ::com::sun::star::uno;
  37 using namespace ::com::sun::star::xml::sax;
  38 using ::oox::core::ContextHandler2;
  39 using ::oox::core::ContextHandlerRef;
  40
  41 namespace oox::drawingml {
  42
  43 SolidFillContext::SolidFillContext(ContextHandler2Helper const & rParent, FillProperties& rFillProps, model::SolidFill* pSolidFill)
  44     : ColorContext(rParent, rFillProps.maFillColor, pSolidFill ? &pSolidFill->maColor : nullptr)
  45 {
  46 }
  47
  48 SolidFillContext::~SolidFillContext()
  49 {}
  50
  51 GradientFillContext::GradientFillContext(ContextHandler2Helper const & rParent,
  52         const AttributeList& rAttribs, GradientFillProperties& rGradientProps, model::GradientFill* pGradientFill)
  53     : ContextHandler2(rParent)
  54     , mpGradientFill(pGradientFill)
  55     , mrGradientProps(rGradientProps)
  56 {
  57     auto oRotateWithShape = rAttribs.getBool(XML_rotWithShape);
  58     mrGradientProps.moShadeFlip = rAttribs.getToken( XML_flip );
  59     mrGradientProps.moRotateWithShape = oRotateWithShape;
  60     if (mpGradientFill && oRotateWithShape)
  61         mpGradientFill->mbRotateWithShape = *oRotateWithShape;
  62 }
  63
  64 ContextHandlerRef GradientFillContext::onCreateContext(
  65         sal_Int32 nElement, const AttributeList& rAttribs )
  66 {
  67     switch( nElement )
  68     {
  69         case A_TOKEN( gsLst ):
  70             return this;    // for gs elements
  71
  72         case A_TOKEN( gs ):
  73             if (rAttribs.hasAttribute(XML_pos))
  74             {
  75                 double fPosition = getLimitedValue<double>(rAttribs.getDouble(XML_pos, 0.0) / 100000.0, 0.0, 1.0);
  76                 auto aElement = mrGradientProps.maGradientStops.emplace(fPosition, Color());
  77
  78                 model::ComplexColor* pComplexColor = nullptr;
  79                 if (mpGradientFill)
  80                 {
  81                     model::GradientStop& rStop = mpGradientFill->maGradientStops.emplace_back();
  82                     rStop.mfPosition = fPosition;
  83                     pComplexColor = &rStop.maColor;
  84                 }
  85
  86                 return new ColorContext(*this, aElement->second, pComplexColor);
  87             }
  88         break;
  89
  90         case A_TOKEN( lin ):
  91         {
  92             mrGradientProps.moShadeAngle = rAttribs.getInteger(XML_ang);
  93             mrGradientProps.moShadeScaled = rAttribs.getBool(XML_scaled);
  94
  95             if (mpGradientFill)
  96             {
  97                 mpGradientFill->meGradientType = model::GradientType::Linear;
  98                 mpGradientFill->maLinearGradient.mnAngle = rAttribs.getInteger(XML_ang, 0);
  99                 mpGradientFill->maLinearGradient.mbScaled = rAttribs.getBool(XML_scaled, false);
 100             }
 101         }
 102         break;
 103
 104         case A_TOKEN( path ):
 105         {
 106             // always set a path type, this disables linear gradient in conversion
 107             sal_Int32 nToken = rAttribs.getToken(XML_path, XML_rect);
 108             mrGradientProps.moGradientPath = nToken;
 109             if (mpGradientFill)
 110             {
 111                 switch (nToken)
 112                 {
 113                     case XML_rect:
 114                         mpGradientFill->meGradientType = model::GradientType::Rectangle;
 115                         break;
 116                     case XML_circle:
 117                         mpGradientFill->meGradientType = model::GradientType::Circle;
 118                         break;
 119                     case XML_shape:
 120                         mpGradientFill->meGradientType = model::GradientType::Shape;
 121                         break;
 122                     default:
 123                         break;
 124                 }
 125             }
 126             return this;    // for fillToRect element
 127         }
 128         case A_TOKEN( fillToRect ):
 129         {
 130             mrGradientProps.moFillToRect = GetRelativeRect( rAttribs.getFastAttributeList() );
 131             if (mpGradientFill)
 132                 fillRelativeRectangle(mpGradientFill->maFillToRectangle, rAttribs.getFastAttributeList());
 133         }
 134         break;
 135
 136         case A_TOKEN( tileRect ):
 137             mrGradientProps.moTileRect = GetRelativeRect(rAttribs.getFastAttributeList());
 138             if (mpGradientFill)
 139                 fillRelativeRectangle(mpGradientFill->maTileRectangle, rAttribs.getFastAttributeList());
 140         break;
 141     }
 142     return nullptr;
 143 }
 144
 145
 146 namespace
 147 {
 148
 149 constexpr frozen::unordered_map<sal_Int32, model::PatternPreset, 54> constPatternPresetMap
 150 {
 151     { XML_pct5, model::PatternPreset::Percent_5 },
 152     { XML_pct10, model::PatternPreset::Percent_10 },
 153     { XML_pct20, model::PatternPreset::Percent_20 },
 154     { XML_pct25, model::PatternPreset::Percent_25 },
 155     { XML_pct30, model::PatternPreset::Percent_30 },
 156     { XML_pct40, model::PatternPreset::Percent_40 },
 157     { XML_pct50, model::PatternPreset::Percent_50 },
 158     { XML_pct60, model::PatternPreset::Percent_60 },
 159     { XML_pct70, model::PatternPreset::Percent_70 },
 160     { XML_pct75, model::PatternPreset::Percent_75 },
 161     { XML_pct80, model::PatternPreset::Percent_80 },
 162     { XML_pct90, model::PatternPreset::Percent_90 },
 163     { XML_horz, model::PatternPreset::Horizontal },
 164     { XML_vert, model::PatternPreset::Vertical },
 165     { XML_ltHorz, model::PatternPreset::LightHorizontal },
 166     { XML_ltVert, model::PatternPreset::LightVertical },
 167     { XML_dkHorz, model::PatternPreset::DarkHorizontal },
 168     { XML_dkVert, model::PatternPreset::DarkVertical },
 169     { XML_narHorz, model::PatternPreset::NarrowHorizontal },
 170     { XML_narVert, model::PatternPreset::NarrowVertical },
 171     { XML_dashHorz, model::PatternPreset::DashedHorizontal },
 172     { XML_dashVert, model::PatternPreset::DashedVertical },
 173     { XML_cross, model::PatternPreset::Cross },
 174     { XML_dnDiag, model::PatternPreset::DownwardDiagonal },
 175     { XML_upDiag, model::PatternPreset::UpwardDiagonal },
 176     { XML_ltDnDiag, model::PatternPreset::LightDownwardDiagonal },
 177     { XML_ltUpDiag, model::PatternPreset::LightUpwardDiagonal },
 178     { XML_dkDnDiag, model::PatternPreset::DarkDownwardDiagonal },
 179     { XML_dkUpDiag, model::PatternPreset::DarkUpwardDiagonal },
 180     { XML_wdDnDiag, model::PatternPreset::WideDownwardDiagonal },
 181     { XML_wdUpDiag, model::PatternPreset::WideUpwardDiagonal },
 182     { XML_dashDnDiag, model::PatternPreset::DashedDownwardDiagonal },
 183     { XML_dashUpDiag, model::PatternPreset::DashedUpwardDiagonal },
 184     { XML_diagCross, model::PatternPreset::DiagonalCross },
 185     { XML_smCheck, model::PatternPreset::SmallCheckerBoard },
 186     { XML_lgCheck, model::PatternPreset::LargeCheckerBoard },
 187     { XML_smGrid, model::PatternPreset::SmallGrid },
 188     { XML_lgGrid, model::PatternPreset::LargeGrid },
 189     { XML_dotGrid, model::PatternPreset::DottedGrid },
 190     { XML_smConfetti, model::PatternPreset::SmallConfetti },
 191     { XML_lgConfetti, model::PatternPreset::LargeConfetti },
 192     { XML_horzBrick, model::PatternPreset::HorizontalBrick },
 193     { XML_diagBrick, model::PatternPreset::DiagonalBrick },
 194     { XML_solidDmnd, model::PatternPreset::SolidDiamond },
 195     { XML_openDmnd, model::PatternPreset::OpenDiamond },
 196     { XML_dotDmnd, model::PatternPreset::DottedDiamond },
 197     { XML_plaid, model::PatternPreset::Plaid },
 198     { XML_sphere, model::PatternPreset::Sphere },
 199     { XML_weave, model::PatternPreset::Weave },
 200     { XML_divot, model::PatternPreset::Divot },
 201     { XML_shingle, model::PatternPreset::Shingle },
 202     { XML_wave, model::PatternPreset::Wave },
 203     { XML_trellis, model::PatternPreset::Trellis },
 204     { XML_zigZag, model::PatternPreset::ZigZag }
 205 };
 206
 207 } // end anonymous namespace
 208 PatternFillContext::PatternFillContext(ContextHandler2Helper const & rParent,
 209         const AttributeList& rAttribs, PatternFillProperties& rPatternProps, model::PatternFill* pPatternFill)
 210     : ContextHandler2(rParent)
 211     , mpPatternFill(pPatternFill)
 212     , mrPatternProps(rPatternProps)
 213 {
 214     mrPatternProps.moPattPreset = rAttribs.getToken(XML_prst);
 215
 216     if (mpPatternFill)
 217     {
 218         sal_Int32 nToken = rAttribs.getToken(XML_prst, XML_TOKEN_INVALID);
 219
 220         auto aIterator = constPatternPresetMap.find(nToken);
 221         if (aIterator != constPatternPresetMap.end())
 222         {
 223             auto const& aPair = *aIterator;
 224             model::PatternPreset ePatternPreset = aPair.second;
 225             mpPatternFill->mePatternPreset = ePatternPreset;
 226         }
 227     }
 228 }
 229
 230 ContextHandlerRef PatternFillContext::onCreateContext(
 231         sal_Int32 nElement, const AttributeList& )
 232 {
 233     model::ComplexColor* pComplexColor = nullptr;
 234     switch( nElement )
 235     {
 236         case A_TOKEN( bgClr ):
 237             if (mpPatternFill)
 238                 pComplexColor = &mpPatternFill->maBackgroundColor;
 239             return new ColorContext(*this, mrPatternProps.maPattBgColor, pComplexColor);
 240         case A_TOKEN( fgClr ):
 241             if (mpPatternFill)
 242                 pComplexColor = &mpPatternFill->maForegroundColor;
 243             return new ColorContext(*this, mrPatternProps.maPattFgColor, pComplexColor);
 244     }
 245     return nullptr;
 246 }
 247
 248 ColorChangeContext::ColorChangeContext( ContextHandler2Helper const & rParent,
 249         const AttributeList& rAttribs, BlipFillProperties& rBlipProps, model::BlipFill* pBlipFill)
 250     : ContextHandler2(rParent)
 251     , mpBlipFill(pBlipFill)
 252     , mrBlipProps(rBlipProps)
 253 {
 254     mrBlipProps.maColorChangeFrom.setUnused();
 255     mrBlipProps.maColorChangeTo.setUnused();
 256     mbUseAlpha = rAttribs.getBool( XML_useA, true );
 257     if (mpBlipFill)
 258     {
 259         auto& rEffect = mpBlipFill->maBlipEffects.emplace_back();
 260         rEffect.meType = model::BlipEffectType::ColorChange;
 261         rEffect.mbUseAlpha = mbUseAlpha;
 262     }
 263 }
 264
 265 ColorChangeContext::~ColorChangeContext()
 266 {
 267     if( !mbUseAlpha )
 268         mrBlipProps.maColorChangeTo.clearTransparence();
 269 }
 270
 271 ContextHandlerRef ColorChangeContext::onCreateContext(
 272         sal_Int32 nElement, const AttributeList& )
 273 {
 274     model::ComplexColor* pComplexColor = nullptr;
 275     switch (nElement)
 276     {
 277         case A_TOKEN(clrFrom):
 278             if (mpBlipFill)
 279             {
 280                 auto& rEffect = mpBlipFill->maBlipEffects.back();
 281                 pComplexColor = &rEffect.getColorFrom();
 282             }
 283             return new ColorContext(*this, mrBlipProps.maColorChangeFrom, pComplexColor);
 284         case A_TOKEN(clrTo):
 285             if (mpBlipFill)
 286             {
 287                 auto& rEffect = mpBlipFill->maBlipEffects.back();
 288                 pComplexColor = &rEffect.getColorTo();
 289             }
 290             return new ColorContext(*this, mrBlipProps.maColorChangeTo, pComplexColor);
 291     }
 292     return nullptr;
 293 }
 294
 295 BlipContext::BlipContext(ContextHandler2Helper const & rParent, const AttributeList& rAttribs,
 296         BlipFillProperties& rBlipProps, model::BlipFill* pBlipFill)
 297     : ContextHandler2(rParent)
 298     , mpBlipFill(pBlipFill)
 299     , mrBlipProps(rBlipProps)
 300 {
 301     if( rAttribs.hasAttribute( R_TOKEN( embed ) ) )
 302     {
 303         // internal picture URL
 304         OUString aFragmentPath = getFragmentPathFromRelId( rAttribs.getStringDefaulted( R_TOKEN( embed )) );
 305         if (!aFragmentPath.isEmpty())
 306         {
 307             auto xGraphic = getFilter().getGraphicHelper().importEmbeddedGraphic(aFragmentPath);
 308             mrBlipProps.mxFillGraphic = xGraphic;
 309             if (mpBlipFill)
 310                 mpBlipFill->mxGraphic = xGraphic;
 311         }
 312     }
 313     else if( rAttribs.hasAttribute( R_TOKEN( link ) ) )
 314     {
 315         // external URL
 316
 317         // we will embed this link, this is better than just doing nothing...
 318         // TODO: import this graphic as real link, but this requires some
 319         // code rework.
 320         OUString aRelId = rAttribs.getStringDefaulted( R_TOKEN( link ));
 321         OUString aTargetLink = getFilter().getAbsoluteUrl( getRelations().getExternalTargetFromRelId( aRelId ) );
 322         GraphicExternalLink aLink(aTargetLink);
 323         Graphic aGraphic(aLink);
 324         auto xGraphic = aGraphic.GetXGraphic();
 325         mrBlipProps.mxFillGraphic = xGraphic;
 326         if (mpBlipFill)
 327             mpBlipFill->mxGraphic = xGraphic;
 328     }
 329 }
 330
 331 ContextHandlerRef BlipContext::onCreateContext(
 332         sal_Int32 nElement, const AttributeList& rAttribs )
 333 {
 334     switch( nElement )
 335     {
 336         case A_TOKEN( biLevel ):
 337         {
 338             sal_Int32 nTreshold = rAttribs.getInteger(XML_thresh, 0);
 339
 340             mrBlipProps.moBiLevelThreshold = nTreshold;
 341             mrBlipProps.moColorEffect = getBaseToken(nElement);
 342
 343             if (mpBlipFill)
 344             {
 345                 auto& rEffect = mpBlipFill->maBlipEffects.emplace_back();
 346                 rEffect.meType = model::BlipEffectType::BiLevel;
 347                 rEffect.mnThreshold = nTreshold;
 348             }
 349         }
 350         break;
 351
 352         case A_TOKEN( grayscl ):
 353         {
 354             mrBlipProps.moColorEffect = getBaseToken( nElement );
 355             if (mpBlipFill)
 356             {
 357                 auto& rEffect = mpBlipFill->maBlipEffects.emplace_back();
 358                 rEffect.meType = model::BlipEffectType::Grayscale;
 359             }
 360         }
 361         break;
 362
 363         case A_TOKEN( clrChange ):
 364         {
 365             return new ColorChangeContext(*this, rAttribs, mrBlipProps, mpBlipFill);
 366         }
 367         break;
 368         case A_TOKEN( duotone ):
 369             return new DuotoneContext( *this, mrBlipProps );
 370
 371         case A_TOKEN( extLst ):
 372             return new BlipExtensionContext( *this, mrBlipProps );
 373
 374         case A_TOKEN( lum ):
 375         {
 376             mrBlipProps.moBrightness = rAttribs.getInteger( XML_bright );
 377             mrBlipProps.moContrast = rAttribs.getInteger( XML_contrast );
 378
 379             if (mpBlipFill)
 380             {
 381                 auto& rEffect = mpBlipFill->maBlipEffects.emplace_back();
 382                 rEffect.meType = model::BlipEffectType::Luminance;
 383                 rEffect.mnBrightness = rAttribs.getInteger(XML_bright, 0);
 384                 rEffect.mnContrast = rAttribs.getInteger(XML_contrast, 0);
 385             }
 386         }
 387         break;
 388         case A_TOKEN( alphaModFix ):
 389         {
 390             mrBlipProps.moAlphaModFix = rAttribs.getInteger(XML_amt);
 391             if (mpBlipFill)
 392             {
 393                 auto& rEffect = mpBlipFill->maBlipEffects.emplace_back();
 394                 rEffect.meType = model::BlipEffectType::AlphaModulateFixed;
 395                 rEffect.mnAmount = rAttribs.getInteger(XML_amt, 100 * 1000);
 396             }
 397         }
 398         break;
 399     }
 400     return nullptr;
 401 }
 402
 403 DuotoneContext::DuotoneContext( ContextHandler2Helper const & rParent,
 404         BlipFillProperties& rBlipProps ) :
 405     ContextHandler2( rParent ),
 406     mrBlipProps( rBlipProps ),
 407     mnColorIndex( 0 )
 408 {
 409     mrBlipProps.maDuotoneColors[0].setUnused();
 410     mrBlipProps.maDuotoneColors[1].setUnused();
 411 }
 412
 413 DuotoneContext::~DuotoneContext()
 414 {
 415 }
 416
 417 ::oox::core::ContextHandlerRef DuotoneContext::onCreateContext(
 418         sal_Int32 /*nElement*/, const AttributeList& /*rAttribs*/ )
 419 {
 420     if( mnColorIndex < 2 )
 421         return new ColorValueContext(*this, mrBlipProps.maDuotoneColors[mnColorIndex++], nullptr);
 422     return nullptr;
 423 }
 424
 425 BlipFillContext::BlipFillContext(ContextHandler2Helper const & rParent, const AttributeList& rAttribs,
 426         BlipFillProperties& rBlipProps, model::BlipFill* pBlipFill)
 427     : ContextHandler2( rParent )
 428     , mpBlipFill(pBlipFill)
 429     , mrBlipProps(rBlipProps)
 430 {
 431     mrBlipProps.moRotateWithShape = rAttribs.getBool( XML_rotWithShape );
 432     if (mpBlipFill)
 433         mpBlipFill->mbRotateWithShape = rAttribs.getBool(XML_rotWithShape, false);
 434 }
 435
 436 ContextHandlerRef BlipFillContext::onCreateContext(
 437         sal_Int32 nElement, const AttributeList& rAttribs )
 438 {
 439     switch( nElement )
 440     {
 441         case A_TOKEN( blip ):
 442             return new BlipContext(*this, rAttribs, mrBlipProps, mpBlipFill);
 443
 444         case A_TOKEN( srcRect ):
 445         {
 446             mrBlipProps.moClipRect = GetRelativeRect( rAttribs.getFastAttributeList() );
 447
 448             if (mpBlipFill)
 449                 fillRelativeRectangle(mpBlipFill->maClipRectangle, rAttribs.getFastAttributeList());
 450         }
 451         break;
 452
 453         case A_TOKEN( tile ):
 454         {
 455             mrBlipProps.moBitmapMode = getBaseToken( nElement );
 456             mrBlipProps.moTileOffsetX = rAttribs.getInteger( XML_tx );
 457             mrBlipProps.moTileOffsetY = rAttribs.getInteger( XML_ty );
 458             mrBlipProps.moTileScaleX = rAttribs.getInteger( XML_sx );
 459             mrBlipProps.moTileScaleY = rAttribs.getInteger( XML_sy );
 460             mrBlipProps.moTileAlign = rAttribs.getToken( XML_algn );
 461             mrBlipProps.moTileFlip = rAttribs.getToken( XML_flip );
 462
 463             if (mpBlipFill)
 464             {
 465                 mpBlipFill->meMode = model::BitmapMode::Tile;
 466                 mpBlipFill->mnTileOffsetX = rAttribs.getInteger(XML_tx, 0);
 467                 mpBlipFill->mnTileOffsetY = rAttribs.getInteger(XML_ty, 0);
 468                 mpBlipFill->mnTileScaleX = rAttribs.getInteger(XML_sx, 0);
 469                 mpBlipFill->mnTileScaleY = rAttribs.getInteger(XML_sy, 0);
 470
 471                 switch (rAttribs.getToken(XML_flip, XML_none))
 472                 {
 473                     case XML_x: mpBlipFill->meTileFlipMode = model::FlipMode::X; break;
 474                     case XML_y: mpBlipFill->meTileFlipMode = model::FlipMode::Y; break;
 475                     case XML_xy: mpBlipFill->meTileFlipMode = model::FlipMode::XY; break;
 476                     default:
 477                     case XML_none: mpBlipFill->meTileFlipMode = model::FlipMode::None; break;
 478                 }
 479                 mpBlipFill->meTileAlignment = convertToRectangleAlignment(rAttribs.getToken(XML_algn, XML_TOKEN_INVALID));
 480             }
 481         }
 482         break;
 483
 484         case A_TOKEN( stretch ):
 485         {
 486             mrBlipProps.moBitmapMode = getBaseToken( nElement );
 487             if (mpBlipFill)
 488             {
 489                 mpBlipFill->meMode = model::BitmapMode::Stretch;
 490             }
 491             return this;    // for fillRect element
 492         }
 493         break;
 494
 495         case A_TOKEN( fillRect ):
 496         {
 497             mrBlipProps.moFillRect = GetRelativeRect( rAttribs.getFastAttributeList() );
 498
 499             if (mpBlipFill)
 500                 fillRelativeRectangle(mpBlipFill->maFillRectangle, rAttribs.getFastAttributeList());
 501         }
 502         break;
 503     }
 504     return nullptr;
 505 }
 506
 507 FillPropertiesContext::FillPropertiesContext( ContextHandler2Helper const & rParent, FillProperties& rFillProps ) :
 508     ContextHandler2( rParent ),
 509     mrFillProps( rFillProps )
 510 {
 511 }
 512
 513 ContextHandlerRef FillPropertiesContext::onCreateContext(
 514         sal_Int32 nElement, const AttributeList& rAttribs )
 515 {
 516     return createFillContext(*this, nElement, rAttribs, mrFillProps, &maFillStyle);
 517 }
 518
 519 ContextHandlerRef FillPropertiesContext::createFillContext(
 520         ContextHandler2Helper const & rParent, sal_Int32 nElement,
 521         const AttributeList& rAttribs, FillProperties& rFillProps,
 522         model::FillStyle* pFillStyle)
 523 {
 524     switch( nElement )
 525     {
 526         case A_TOKEN( noFill ):
 527         {
 528             rFillProps.moFillType = getBaseToken(nElement);
 529             if (pFillStyle)
 530             {
 531                 pFillStyle->mpFill = std::make_shared<model::NoFill>();
 532             }
 533             return nullptr;
 534         }
 535         case A_TOKEN( solidFill ):
 536         {
 537             rFillProps.moFillType = getBaseToken(nElement);
 538             model::SolidFill* pSolidFill = nullptr;
 539             if (pFillStyle)
 540             {
 541                 pFillStyle->mpFill = std::make_shared<model::SolidFill>();
 542                 pSolidFill = static_cast<model::SolidFill*>(pFillStyle->mpFill.get());
 543             }
 544             return new SolidFillContext(rParent, rFillProps, pSolidFill);
 545         }
 546         case A_TOKEN( gradFill ):
 547         {
 548             rFillProps.moFillType = getBaseToken(nElement);
 549             model::GradientFill* pGradientFill = nullptr;
 550             if (pFillStyle)
 551             {
 552                 pFillStyle->mpFill = std::make_shared<model::GradientFill>();
 553                 pGradientFill = static_cast<model::GradientFill*>(pFillStyle->mpFill.get());
 554             }
 555             return new GradientFillContext(rParent, rAttribs, rFillProps.maGradientProps, pGradientFill);
 556         }
 557         case A_TOKEN( pattFill ):
 558         {
 559             rFillProps.moFillType = getBaseToken( nElement );
 560             model::PatternFill* pPatternFill = nullptr;
 561             if (pFillStyle)
 562             {
 563                 auto pFill = std::make_shared<model::PatternFill>();
 564                 pPatternFill = pFill.get();
 565                 pFillStyle->mpFill = pFill;
 566             }
 567             return new PatternFillContext(rParent, rAttribs, rFillProps.maPatternProps, pPatternFill);
 568         }
 569         case A_TOKEN( blipFill ):
 570         {
 571             rFillProps.moFillType = getBaseToken( nElement );
 572             model::BlipFill* pBlipFill = nullptr;
 573             if (pFillStyle)
 574             {
 575                 pFillStyle->mpFill = std::make_unique<model::BlipFill>();
 576                 pBlipFill = static_cast<model::BlipFill*>(pFillStyle->mpFill.get());
 577             }
 578             return new BlipFillContext( rParent, rAttribs, rFillProps.maBlipProps, pBlipFill);
 579         }
 580         case A_TOKEN( grpFill ):
 581         {
 582             // TODO
 583             rFillProps.moFillType = getBaseToken( nElement );
 584             return nullptr;
 585         };
 586     }
 587     return nullptr;
 588 }
 589
 590 SimpleFillPropertiesContext::SimpleFillPropertiesContext( ContextHandler2Helper const & rParent, Color& rColor ) :
 591     FillPropertiesContext( rParent, *this ),
 592     mrColor( rColor )
 593 {
 594 }
 595
 596 SimpleFillPropertiesContext::~SimpleFillPropertiesContext()
 597 {
 598     mrColor = getBestSolidColor();
 599 }
 600
 601 BlipExtensionContext::BlipExtensionContext( ContextHandler2Helper const & rParent, BlipFillProperties& rBlipProps ) :
 602     ContextHandler2( rParent ),
 603     mrBlipProps( rBlipProps )
 604 {
 605 }
 606
 607 BlipExtensionContext::~BlipExtensionContext()
 608 {
 609 }
 610
 611 ContextHandlerRef BlipExtensionContext::onCreateContext(
 612         sal_Int32 nElement, const AttributeList& )
 613 {
 614     switch( nElement )
 615     {
 616         case A_TOKEN( ext ):
 617             return new BlipExtensionContext( *this, mrBlipProps );
 618
 619         case OOX_TOKEN( a14, imgProps ):
 620             return new ArtisticEffectContext( *this, mrBlipProps.maEffect );
 621     }
 622     return nullptr;
 623 }
 624
 625 ArtisticEffectContext::ArtisticEffectContext( ContextHandler2Helper const & rParent, ArtisticEffectProperties& rEffect ) :
 626     ContextHandler2( rParent ),
 627     maEffect( rEffect )
 628 {
 629 }
 630
 631 ArtisticEffectContext::~ArtisticEffectContext()
 632 {
 633 }
 634
 635 ContextHandlerRef ArtisticEffectContext::onCreateContext(
 636         sal_Int32 nElement, const AttributeList& rAttribs )
 637 {
 638     // containers
 639     if( nElement == OOX_TOKEN( a14, imgLayer ) )
 640     {
 641         if( rAttribs.hasAttribute( R_TOKEN( embed ) ) )
 642         {
 643             OUString aFragmentPath = getFragmentPathFromRelId( rAttribs.getStringDefaulted( R_TOKEN( embed )) );
 644             if( !aFragmentPath.isEmpty() )
 645             {
 646                 getFilter().importBinaryData( maEffect.mrOleObjectInfo.maEmbeddedData, aFragmentPath );
 647                 maEffect.mrOleObjectInfo.maProgId = aFragmentPath;
 648             }
 649         }
 650         return new ArtisticEffectContext( *this, maEffect );
 651     }
 652     if( nElement == OOX_TOKEN( a14, imgEffect ) )
 653         return new ArtisticEffectContext( *this, maEffect );
 654
 655     // effects
 656     maEffect.msName = ArtisticEffectProperties::getEffectString( nElement );
 657     if( maEffect.isEmpty() )
 658         return nullptr;
 659
 660     // effect attributes
 661     sal_Int32 const aAttribs[19] = {
 662             XML_visible, XML_trans, XML_crackSpacing, XML_pressure, XML_numberOfShades,
 663             XML_grainSize, XML_intensity, XML_smoothness, XML_gridSize, XML_pencilSize,
 664             XML_size, XML_brushSize, XML_scaling, XML_detail, XML_bright, XML_contrast,
 665             XML_colorTemp, XML_sat, XML_amount
 666     };
 667     for(sal_Int32 nAttrib : aAttribs)
 668     {
 669         if( rAttribs.hasAttribute( nAttrib ) )
 670         {
 671             OUString sName = ArtisticEffectProperties::getEffectString( nAttrib );
 672             if( !sName.isEmpty() )
 673                 maEffect.maAttribs[sName] <<= rAttribs.getInteger( nAttrib, 0 );
 674         }
 675     }
 676
 677     return nullptr;
 678 }
 679
 680 } // namespace oox::drawingml
 681
 682 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */