oox/source/ppt/pptfilterhelpers.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 <com/sun/star/animations/TransitionType.hpp>
  21 #include <com/sun/star/animations/TransitionSubType.hpp>
  22 #include <com/sun/star/animations/ValuePair.hpp>
  23 #include <com/sun/star/awt/FontWeight.hpp>
  24 #include <com/sun/star/awt/FontUnderline.hpp>
  25 #include <com/sun/star/awt/FontSlant.hpp>
  26 #include <com/sun/star/drawing/LineStyle.hpp>
  27 #include <com/sun/star/drawing/FillStyle.hpp>
  28 #include <com/sun/star/uno/Sequence.hxx>
  29 #include <oox/ppt/pptfilterhelpers.hxx>
  30 #include <tools/color.hxx>
  31 #include <o3tl/string_view.hxx>
  32
  33 namespace {
  34     int lcl_gethex(int nChar)
  35     {
  36         if (nChar >= '0' && nChar <= '9')
  37             return nChar - '0';
  38         else if (nChar >= 'a' && nChar <= 'f')
  39             return nChar - 'a' + 10;
  40         else if (nChar >= 'A' && nChar <= 'F')
  41             return nChar - 'A' + 10;
  42         else
  43             return 0;
  44     }
  45 }
  46
  47 namespace oox::ppt {
  48
  49     const ImplAttributeNameConversion *getAttributeConversionList()
  50     {
  51         static const ImplAttributeNameConversion aList[] =
  52         {
  53             { AnimationAttributeEnum::PPT_X,             "ppt_x",                        "X" },
  54             { AnimationAttributeEnum::PPT_Y,             "ppt_y",                        "Y" },
  55             { AnimationAttributeEnum::PPT_W,             "ppt_w",                        "Width" },
  56             { AnimationAttributeEnum::PPT_H,             "ppt_h",                        "Height" },
  57             { AnimationAttributeEnum::PPT_C,             "ppt_c",                        "DimColor" },
  58             { AnimationAttributeEnum::R,                 "r",                            "Rotate" },
  59             { AnimationAttributeEnum::XSHEAR,            "xshear",                       "SkewX" },
  60             { AnimationAttributeEnum::FILLCOLOR,         "fillcolor",                    "FillColor" },
  61             { AnimationAttributeEnum::FILLCOLOR,         "fillColor",                    "FillColor" },
  62             { AnimationAttributeEnum::FILLTYPE,          "fill.type",                    "FillStyle" },
  63             { AnimationAttributeEnum::FILLON,            "fill.on",                      "FillOn" },
  64             { AnimationAttributeEnum::STROKECOLOR,       "stroke.color",                 "LineColor" },
  65             { AnimationAttributeEnum::STROKEON,          "stroke.on",                    "LineStyle" },
  66             { AnimationAttributeEnum::STYLECOLOR,        "style.color",                  "CharColor" },
  67             { AnimationAttributeEnum::STYLEROTATION,     "style.rotation",               "Rotate" },
  68             { AnimationAttributeEnum::FONTWEIGHT,        "style.fontWeight",             "CharWeight" },
  69             { AnimationAttributeEnum::STYLEUNDERLINE,    "style.textDecorationUnderline","CharUnderline" },
  70             { AnimationAttributeEnum::STYLEFONTFAMILY,   "style.fontFamily",             "CharFontName" },
  71             { AnimationAttributeEnum::STYLEFONTSIZE,     "style.fontSize",               "CharHeight" },
  72             { AnimationAttributeEnum::STYLEFONTSTYLE,    "style.fontStyle",              "CharPosture" },
  73             { AnimationAttributeEnum::STYLEVISIBILITY,   "style.visibility",             "Visibility" },
  74             { AnimationAttributeEnum::STYLEOPACITY,      "style.opacity",                "Opacity" },
  75             { AnimationAttributeEnum::UNKNOWN, nullptr, nullptr }
  76         };
  77
  78         return aList;
  79     }
  80
  81     const transition* transition::getList()
  82     {
  83         static const transition aList[] =
  84         {
  85             { "wipe(up)", css::animations::TransitionType::BARWIPE, css::animations::TransitionSubType::TOPTOBOTTOM, true },
  86             { "wipe(right)", css::animations::TransitionType::BARWIPE, css::animations::TransitionSubType::LEFTTORIGHT, false },
  87             { "wipe(left)", css::animations::TransitionType::BARWIPE, css::animations::TransitionSubType::LEFTTORIGHT, true },
  88             { "wipe(down)", css::animations::TransitionType::BARWIPE, css::animations::TransitionSubType::TOPTOBOTTOM, false },
  89             { "wheel(1)", css::animations::TransitionType::PINWHEELWIPE, css::animations::TransitionSubType::ONEBLADE, true },
  90             { "wheel(2)", css::animations::TransitionType::PINWHEELWIPE, css::animations::TransitionSubType::TWOBLADEVERTICAL, true },
  91             { "wheel(3)", css::animations::TransitionType::PINWHEELWIPE, css::animations::TransitionSubType::THREEBLADE, true },
  92             { "wheel(4)", css::animations::TransitionType::PINWHEELWIPE, css::animations::TransitionSubType::FOURBLADE, true },
  93             { "wheel(8)", css::animations::TransitionType::PINWHEELWIPE, css::animations::TransitionSubType::EIGHTBLADE, true },
  94             { "strips(downLeft)", css::animations::TransitionType::WATERFALLWIPE, css::animations::TransitionSubType::HORIZONTALRIGHT, true },
  95             { "strips(upLeft)", css::animations::TransitionType::WATERFALLWIPE, css::animations::TransitionSubType::HORIZONTALLEFT, false },
  96             { "strips(downRight)", css::animations::TransitionType::WATERFALLWIPE, css::animations::TransitionSubType::HORIZONTALLEFT, true },
  97             { "strips(upRight)", css::animations::TransitionType::WATERFALLWIPE, css::animations::TransitionSubType::HORIZONTALRIGHT, false },
  98             { "barn(inVertical)", css::animations::TransitionType::BARNDOORWIPE, css::animations::TransitionSubType::VERTICAL, false },
  99             { "barn(outVertical)", css::animations::TransitionType::BARNDOORWIPE, css::animations::TransitionSubType::VERTICAL, true },
 100             { "barn(inHorizontal)", css::animations::TransitionType::BARNDOORWIPE, css::animations::TransitionSubType::HORIZONTAL, false },
 101             { "barn(outHorizontal)", css::animations::TransitionType::BARNDOORWIPE, css::animations::TransitionSubType::HORIZONTAL, true },
 102             { "randombar(vertical)", css::animations::TransitionType::RANDOMBARWIPE, css::animations::TransitionSubType::VERTICAL, true},
 103             { "randombar(horizontal)", css::animations::TransitionType::RANDOMBARWIPE, css::animations::TransitionSubType::HORIZONTAL, true },
 104             { "checkerboard(down)", css::animations::TransitionType::CHECKERBOARDWIPE, css::animations::TransitionSubType::DOWN, true},
 105             { "checkerboard(across)", css::animations::TransitionType::CHECKERBOARDWIPE, css::animations::TransitionSubType::ACROSS, true },
 106             { "plus(out)", css::animations::TransitionType::FOURBOXWIPE, css::animations::TransitionSubType::CORNERSIN, false },
 107             { "plus(in)", css::animations::TransitionType::FOURBOXWIPE, css::animations::TransitionSubType::CORNERSIN, true },
 108             { "diamond(out)", css::animations::TransitionType::IRISWIPE, css::animations::TransitionSubType::DIAMOND, true },
 109             { "diamond(in)", css::animations::TransitionType::IRISWIPE, css::animations::TransitionSubType::DIAMOND, false },
 110             { "circle(out)", css::animations::TransitionType::ELLIPSEWIPE, css::animations::TransitionSubType::HORIZONTAL, true },
 111             { "circle(in)", css::animations::TransitionType::ELLIPSEWIPE, css::animations::TransitionSubType::HORIZONTAL, false },
 112             { "box(out)", css::animations::TransitionType::IRISWIPE, css::animations::TransitionSubType::RECTANGLE, true },
 113             { "box(in)", css::animations::TransitionType::IRISWIPE, css::animations::TransitionSubType::RECTANGLE, false },
 114             { "wedge", css::animations::TransitionType::FANWIPE, css::animations::TransitionSubType::CENTERTOP, true },
 115             { "blinds(vertical)", css::animations::TransitionType::BLINDSWIPE, css::animations::TransitionSubType::VERTICAL, true },
 116             { "blinds(horizontal)", css::animations::TransitionType::BLINDSWIPE, css::animations::TransitionSubType::HORIZONTAL, true },
 117             { "fade", css::animations::TransitionType::FADE, css::animations::TransitionSubType::CROSSFADE, true },
 118             { "slide(fromTop)", css::animations::TransitionType::SLIDEWIPE, css::animations::TransitionSubType::FROMTOP, true },
 119             { "slide(fromRight)", css::animations::TransitionType::SLIDEWIPE, css::animations::TransitionSubType::FROMRIGHT, true },
 120             { "slide(fromLeft)", css::animations::TransitionType::SLIDEWIPE, css::animations::TransitionSubType::FROMLEFT, true },
 121             { "slide(fromBottom)", css::animations::TransitionType::SLIDEWIPE, css::animations::TransitionSubType::FROMBOTTOM, true },
 122             { "dissolve", css::animations::TransitionType::DISSOLVE, css::animations::TransitionSubType::DEFAULT, true },
 123             { "image", css::animations::TransitionType::DISSOLVE, css::animations::TransitionSubType::DEFAULT, true }, // TODO
 124             { nullptr, 0, 0, false }
 125         };
 126
 127         return aList;
 128     }
 129
 130     const transition* transition::find( std::u16string_view rName )
 131     {
 132         const transition* p = transition::getList();
 133
 134         while( p->mpName )
 135         {
 136             if( o3tl::equalsAscii( rName, p->mpName ) )
 137                 return p;
 138
 139             p++;
 140         }
 141
 142         return nullptr;
 143     }
 144
 145     bool convertMeasure(OUString& rString)
 146     {
 147         bool bRet = false;
 148
 149         const char* pSource[] = { "ppt_x", "ppt_y", "ppt_w", "ppt_h", nullptr };
 150         const char* pDest[] = { "x", "y", "width", "height", nullptr };
 151
 152         /* here we want to substitute all occurrences of
 153          * [#]ppt_[xyhw] with
 154          * x,y,height and width respectively
 155          */
 156         sal_Int32 nIndex = 0;
 157
 158         const char** ps = pSource;
 159         const char** pd = pDest;
 160
 161         while (*ps)
 162         {
 163             if (nIndex == -1)
 164                 nIndex = 0;
 165             const OUString aSearch(OUString::createFromAscii(*ps));
 166             while ((nIndex = rString.indexOf(aSearch, nIndex)) != -1)
 167             {
 168                 sal_Int32 nLength = aSearch.getLength();
 169                 if (nIndex && (rString[nIndex - 1] == '#'))
 170                 {
 171                     nIndex--;
 172                     nLength++;
 173                 }
 174
 175                 const OUString aNew(OUString::createFromAscii(*pd));
 176                 rString = rString.replaceAt(nIndex, nLength, aNew);
 177                 nIndex += aNew.getLength();
 178                 bRet = true;
 179             }
 180             ps++;
 181             pd++;
 182         }
 183
 184         return bRet;
 185     }
 186
 187     bool convertAnimationValue(AnimationAttributeEnum eAttribute, css::uno::Any& rValue)
 188     {
 189         using css::animations::ValuePair;
 190         bool bRet = false;
 191         switch (eAttribute)
 192         {
 193             case AnimationAttributeEnum::PPT_X:
 194             case AnimationAttributeEnum::PPT_Y:
 195             case AnimationAttributeEnum::PPT_W:
 196             case AnimationAttributeEnum::PPT_H:
 197             {
 198                 OUString aString;
 199
 200                 if (rValue.getValueType() == cppu::UnoType<ValuePair>::get())
 201                 {
 202                     ValuePair aValuePair;
 203                     if (rValue >>= aValuePair)
 204                     {
 205                         if (aValuePair.First >>= aString)
 206                         {
 207                             if (convertMeasure(aString))
 208                             {
 209                                 aValuePair.First <<= aString;
 210                                 bRet = true;
 211                             }
 212                         }
 213
 214                         if (aValuePair.Second >>= aString)
 215                         {
 216                             if (convertMeasure(aString))
 217                             {
 218                                 aValuePair.Second <<= aString;
 219                                 bRet = true;
 220                             }
 221                         }
 222                     }
 223                 }
 224                 else if (rValue.getValueType() == cppu::UnoType<OUString>::get())
 225                 {
 226                     if (rValue >>= aString)
 227                     {
 228                         bRet = convertMeasure(aString);
 229
 230                         if (bRet)
 231                             rValue <<= aString;
 232                     }
 233                 }
 234             }
 235             break;
 236
 237             case AnimationAttributeEnum::XSHEAR:
 238             case AnimationAttributeEnum::R:
 239             {
 240                 OUString aString;
 241                 if (rValue >>= aString)
 242                 {
 243                     rValue <<= aString.toDouble();
 244                     bRet = true;
 245                 }
 246             }
 247             break;
 248
 249             case AnimationAttributeEnum::STYLEROTATION:
 250             {
 251                 if (rValue.getValueType() == cppu::UnoType<OUString>::get())
 252                 {
 253                     OUString aString;
 254                     rValue >>= aString;
 255                     rValue <<= static_cast<sal_Int16>(aString.toDouble());
 256                     bRet = true;
 257                 }
 258                 else if (rValue.getValueType() == cppu::UnoType<double>::get())
 259                 {
 260                     double fValue = 0.0;
 261                     rValue >>= fValue;
 262                     rValue <<= static_cast<sal_Int16>(fValue);
 263                     bRet = true;
 264                 }
 265             }
 266             break;
 267
 268             case AnimationAttributeEnum::FILLCOLOR:
 269             case AnimationAttributeEnum::STROKECOLOR:
 270             case AnimationAttributeEnum::STYLECOLOR:
 271             case AnimationAttributeEnum::PPT_C:
 272             {
 273                 OUString aString;
 274                 if (rValue >>= aString)
 275                 {
 276                     if (aString.getLength() >= 7 && aString[0] == '#')
 277                     {
 278                         Color aColor;
 279                         aColor.SetRed(static_cast<sal_uInt8>(lcl_gethex(aString[1]) * 16
 280                                                              + lcl_gethex(aString[2])));
 281                         aColor.SetGreen(static_cast<sal_uInt8>(lcl_gethex(aString[3]) * 16
 282                                                                + lcl_gethex(aString[4])));
 283                         aColor.SetBlue(static_cast<sal_uInt8>(lcl_gethex(aString[5]) * 16
 284                                                               + lcl_gethex(aString[6])));
 285                         rValue <<= aColor;
 286                         bRet = true;
 287                     }
 288                     else if (aString.startsWith("rgb("))
 289                     {
 290                         aString = aString.copy(4, aString.getLength() - 5);
 291                         Color aColor;
 292                         sal_Int32 index = 0;
 293                         aColor.SetRed(
 294                             static_cast<sal_uInt8>(o3tl::toInt32(o3tl::getToken(aString, 0, ',', index))));
 295                         aColor.SetGreen(
 296                             static_cast<sal_uInt8>(o3tl::toInt32(o3tl::getToken(aString, 0, ',', index))));
 297                         aColor.SetRed(
 298                             static_cast<sal_uInt8>(o3tl::toInt32(o3tl::getToken(aString, 0, ',', index))));
 299                         rValue <<= aColor;
 300                         bRet = true;
 301                     }
 302                     else if (aString.startsWith("hsl("))
 303                     {
 304                         sal_Int32 index = 0;
 305                         sal_Int32 nA = o3tl::toInt32(o3tl::getToken(aString, 0, ',', index));
 306                         sal_Int32 nB = o3tl::toInt32(o3tl::getToken(aString, 0, ',', index));
 307                         sal_Int32 nC = o3tl::toInt32(o3tl::getToken(aString, 0, ',', index));
 308                         css::uno::Sequence<double> aHSL
 309                         {
 310                             nA * 360.0 / 255.0,
 311                             nB / 255.0,
 312                             nC / 255.0
 313                         };
 314                         rValue <<= aHSL;
 315                         bRet = true;
 316                     }
 317                 }
 318             }
 319             break;
 320             case AnimationAttributeEnum::FILLON:
 321             {
 322                 // Slideshow doesn't support FillOn, but we need to convert the value type
 323                 // so it can be written out again.
 324                 OUString aString;
 325                 if (rValue >>= aString)
 326                 {
 327                     rValue <<= aString == "true";
 328                     bRet = true;
 329                 }
 330             }
 331             break;
 332
 333             case AnimationAttributeEnum::FILLTYPE:
 334             {
 335                 OUString aString;
 336                 if (rValue >>= aString)
 337                 {
 338                     rValue <<= aString == "solid" ? css::drawing::FillStyle_SOLID
 339                                                   : css::drawing::FillStyle_NONE;
 340                     bRet = true;
 341                 }
 342             }
 343             break;
 344
 345             case AnimationAttributeEnum::STROKEON:
 346             {
 347                 OUString aString;
 348                 if (rValue >>= aString)
 349                 {
 350                     rValue <<= aString == "true" ? css::drawing::LineStyle_SOLID
 351                                                  : css::drawing::LineStyle_NONE;
 352                     bRet = true;
 353                 }
 354             }
 355             break;
 356
 357             case AnimationAttributeEnum::FONTWEIGHT:
 358             {
 359                 OUString aString;
 360                 if (rValue >>= aString)
 361                 {
 362                     rValue <<= aString == "bold" ? css::awt::FontWeight::BOLD
 363                                                  : css::awt::FontWeight::NORMAL;
 364                     bRet = true;
 365                 }
 366             }
 367             break;
 368
 369             case AnimationAttributeEnum::STYLEFONTSTYLE:
 370             {
 371                 OUString aString;
 372                 if (rValue >>= aString)
 373                 {
 374                     rValue
 375                         <<= aString == "italic" ? css::awt::FontSlant_ITALIC : css::awt::FontSlant_NONE;
 376                     bRet = true;
 377                 }
 378             }
 379             break;
 380
 381             case AnimationAttributeEnum::STYLEUNDERLINE:
 382             {
 383                 OUString aString;
 384                 if (rValue >>= aString)
 385                 {
 386                     rValue <<= aString == "true" ? css::awt::FontUnderline::SINGLE
 387                                                  : css::awt::FontUnderline::NONE;
 388                     bRet = true;
 389                 }
 390             }
 391             break;
 392
 393             case AnimationAttributeEnum::STYLEOPACITY:
 394             case AnimationAttributeEnum::STYLEFONTSIZE:
 395             {
 396                 OUString aString;
 397                 if (rValue >>= aString)
 398                 {
 399                     rValue <<= static_cast<float>(aString.toDouble());
 400                     bRet = true;
 401                 }
 402             }
 403             break;
 404
 405             case AnimationAttributeEnum::STYLEVISIBILITY:
 406             {
 407                 OUString aString;
 408                 if (rValue >>= aString)
 409                 {
 410                     rValue <<= aString == "visible";
 411                     bRet = true;
 412                 }
 413             }
 414             break;
 415             default:
 416                 break;
 417         }
 418
 419         return bRet;
 420     }
 421
 422 }
 423
 424 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */