Quelle  shape3dproperties.cxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#include <drawingml/shape3dproperties.hxx>
#include <com/sun/star/drawing/BitmapMode.hpp>
#include <com/sun/star/graphic/XGraphicTransformer.hpp>

#include <comphelper/propertyvalue.hxx>
#include <oox/token/tokens.hxx>
#include <sal/log.hxx>

using namespace ::com::sun::star;


namespace oox::drawingml {

OUString Generic3DProperties::getCameraPrstName( sal_Int32 nElement )
{
    switch( nElement )
    {
        case XML_legacyObliqueTopLeft:          return u"legacyObliqueTopLeft"_ustr;
        case XML_legacyObliqueTop:              return u"legacyObliqueTop"_ustr;
        case XML_legacyObliqueTopRight:         return u"legacyObliqueTopRight"_ustr;
        case XML_legacyObliqueLeft:             return u"legacyObliqueLeft"_ustr;
        case XML_legacyObliqueFront:            return u"legacyObliqueFront"_ustr;
        case XML_legacyObliqueRight:            return u"legacyObliqueRight"_ustr;
        case XML_legacyObliqueBottomLeft:       return u"legacyObliqueBottomLeft"_ustr;
        case XML_legacyObliqueBottom:           return u"legacyObliqueBottom"_ustr;
        case XML_legacyObliqueBottomRight:      return u"legacyObliqueBottomRight"_ustr;
        case XML_legacyPerspectiveTopLeft:      return u"legacyPerspectiveTopLeft"_ustr;
        case XML_legacyPerspectiveTop:          return u"legacyPerspectiveTop"_ustr;
        case XML_legacyPerspectiveTopRight:     return u"legacyPerspectiveTopRight"_ustr;
        case XML_legacyPerspectiveLeft:         return u"legacyPerspectiveLeft"_ustr;
        case XML_legacyPerspectiveFront:        return u"legacyPerspectiveFront"_ustr;
        case XML_legacyPerspectiveRight:        return u"legacyPerspectiveRight"_ustr;
        case XML_legacyPerspectiveBottomLeft:   return u"legacyPerspectiveBottomLeft"_ustr;
        case XML_legacyPerspectiveBottom:       return u"legacyPerspectiveBottom"_ustr;
        case XML_legacyPerspectiveBottomRight:  return u"legacyPerspectiveBottomRight"_ustr;
        case XML_orthographicFront:             return u"orthographicFront"_ustr;
        case XML_isometricTopUp:                return u"isometricTopUp"_ustr;
        case XML_isometricTopDown:              return u"isometricTopDown"_ustr;
        case XML_isometricBottomUp:             return u"isometricBottomUp"_ustr;
        case XML_isometricBottomDown:           return u"isometricBottomDown"_ustr;
        case XML_isometricLeftUp:               return u"isometricLeftUp"_ustr;
        case XML_isometricLeftDown:             return u"isometricLeftDown"_ustr;
        case XML_isometricRightUp:              return u"isometricRightUp"_ustr;
        case XML_isometricRightDown:            return u"isometricRightDown"_ustr;
        case XML_isometricOffAxis1Left:         return u"isometricOffAxis1Left"_ustr;
        case XML_isometricOffAxis1Right:        return u"isometricOffAxis1Right"_ustr;
        case XML_isometricOffAxis1Top:          return u"isometricOffAxis1Top"_ustr;
        case XML_isometricOffAxis2Left:         return u"isometricOffAxis2Left"_ustr;
        case XML_isometricOffAxis2Right:        return u"isometricOffAxis2Right"_ustr;
        case XML_isometricOffAxis2Top:          return u"isometricOffAxis2Top"_ustr;
        case XML_isometricOffAxis3Left:         return u"isometricOffAxis3Left"_ustr;
        case XML_isometricOffAxis3Right:        return u"isometricOffAxis3Right"_ustr;
        case XML_isometricOffAxis3Bottom:       return u"isometricOffAxis3Bottom"_ustr;
        case XML_isometricOffAxis4Left:         return u"isometricOffAxis4Left"_ustr;
        case XML_isometricOffAxis4Right:        return u"isometricOffAxis4Right"_ustr;
        case XML_isometricOffAxis4Bottom:       return u"isometricOffAxis4Bottom"_ustr;
        case XML_obliqueTopLeft:                return u"obliqueTopLeft"_ustr;
        case XML_obliqueTop:                    return u"obliqueTop"_ustr;
        case XML_obliqueTopRight:               return u"obliqueTopRight"_ustr;
        case XML_obliqueLeft:                   return u"obliqueLeft"_ustr;
        case XML_obliqueRight:                  return u"obliqueRight"_ustr;
        case XML_obliqueBottomLeft:             return u"obliqueBottomLeft"_ustr;
        case XML_obliqueBottom:                 return u"obliqueBottom"_ustr;
        case XML_obliqueBottomRight:            return u"obliqueBottomRight"_ustr;
        case XML_perspectiveFront:              return u"perspectiveFront"_ustr;
        case XML_perspectiveLeft:               return u"perspectiveLeft"_ustr;
        case XML_perspectiveRight:              return u"perspectiveRight"_ustr;
        case XML_perspectiveAbove:              return u"perspectiveAbove"_ustr;
        case XML_perspectiveBelow:              return u"perspectiveBelow"_ustr;
        case XML_perspectiveAboveLeftFacing:        return u"perspectiveAboveLeftFacing"_ustr;
        case XML_perspectiveAboveRightFacing:       return u"perspectiveAboveRightFacing"_ustr;
        case XML_perspectiveContrastingLeftFacing:  return u"perspectiveContrastingLeftFacing"_ustr;
        case XML_perspectiveContrastingRightFacing: return u"perspectiveContrastingRightFacing"_ustr;
        case XML_perspectiveHeroicLeftFacing:       return u"perspectiveHeroicLeftFacing"_ustr;
        case XML_perspectiveHeroicRightFacing:      return u"perspectiveHeroicRightFacing"_ustr;
        case XML_perspectiveHeroicExtremeLeftFacing:    return u"perspectiveHeroicExtremeLeftFacing"_ustr;
        case XML_perspectiveHeroicExtremeRightFacing:   return u"perspectiveHeroicExtremeRightFacing"_ustr;
        case XML_perspectiveRelaxed:                    return u"perspectiveRelaxed"_ustr;
        case XML_perspectiveRelaxedModerately:          return u"perspectiveRelaxedModerately"_ustr;
    }
    SAL_WARN( "oox.drawingml", "Generic3DProperties::getCameraPrstName - unexpected prst type" );
    return OUString();
}

OUString Generic3DProperties::getLightRigName( sal_Int32 nElement )
{
    switch( nElement )
    {
        case XML_legacyFlat1:       return u"legacyFlat1"_ustr;
        case XML_legacyFlat2:       return u"legacyFlat2"_ustr;
        case XML_legacyFlat3:       return u"legacyFlat3"_ustr;
        case XML_legacyFlat4:       return u"legacyFlat4"_ustr;
        case XML_legacyNormal1:     return u"legacyNormal1"_ustr;
        case XML_legacyNormal2:     return u"legacyNormal2"_ustr;
        case XML_legacyNormal3:     return u"legacyNormal3"_ustr;
        case XML_legacyNormal4:     return u"legacyNormal4"_ustr;
        case XML_legacyHarsh1:      return u"legacyHarsh1"_ustr;
        case XML_legacyHarsh2:      return u"legacyHarsh2"_ustr;
        case XML_legacyHarsh3:      return u"legacyHarsh3"_ustr;
        case XML_legacyHarsh4:      return u"legacyHarsh4"_ustr;
        case XML_threePt:           return u"threePt"_ustr;
        case XML_balanced:          return u"balanced"_ustr;
        case XML_soft:              return u"soft"_ustr;
        case XML_harsh:             return u"harsh"_ustr;
        case XML_flood:             return u"flood"_ustr;
        case XML_contrasting:       return u"contrasting"_ustr;
        case XML_morning:           return u"morning"_ustr;
        case XML_sunrise:           return u"sunrise"_ustr;
        case XML_sunset:            return u"sunset"_ustr;
        case XML_chilly:            return u"chilly"_ustr;
        case XML_freezing:          return u"freezing"_ustr;
        case XML_flat:              return u"flat"_ustr;
        case XML_twoPt:             return u"twoPt"_ustr;
        case XML_glow:              return u"glow"_ustr;
        case XML_brightRoom:        return u"brightRoom"_ustr;
    }
    SAL_WARN( "oox.drawingml", "Generic3DProperties::getLightRigName - unexpected token" );
    return OUString();
}

OUString Generic3DProperties::getLightRigDirName( sal_Int32 nElement )
{
    switch( nElement )
    {
        case XML_tl:    return u"tl"_ustr;
        case XML_t:     return u"t"_ustr;
        case XML_tr:    return u"tr"_ustr;
        case XML_l:     return u"l"_ustr;
        case XML_r:     return u"r"_ustr;
        case XML_bl:    return u"bl"_ustr;
        case XML_b:     return u"b"_ustr;
        case XML_br:    return u"br"_ustr;
    }
    SAL_WARN( "oox.drawingml", "Generic3DProperties::getLightRigDirName - unexpected token" );
    return OUString();
}

OUString Generic3DProperties::getBevelPresetTypeString( sal_Int32 nType )
{
    switch (nType)
    {
        case XML_relaxedInset:  return u"relaxedInset"_ustr;
        case XML_circle:        return u"circle"_ustr;
        case XML_slope:         return u"slope"_ustr;
        case XML_cross:         return u"cross"_ustr;
        case XML_angle:         return u"angle"_ustr;
        case XML_softRound:     return u"softRound"_ustr;
        case XML_convex:        return u"convex"_ustr;
        case XML_coolSlant:     return u"coolSlant"_ustr;
        case XML_divot:         return u"divot"_ustr;
        case XML_riblet:        return u"riblet"_ustr;
        case XML_hardEdge:      return u"hardEdge"_ustr;
        case XML_artDeco:       return u"artDeco"_ustr;
    }
    SAL_WARN( "oox.drawingml", "Generic3DProperties::getBevelPresetTypeString - unexpected token" );
    return OUString();
}

OUString Generic3DProperties::getPresetMaterialTypeString( sal_Int32 nType )
{
    switch (nType)
    {
        case XML_legacyMatte:       return u"legacyMatte"_ustr;
        case XML_legacyPlastic:     return u"legacyPlastic"_ustr;
        case XML_legacyMetal:       return u"legacyMetal"_ustr;
        case XML_legacyWireframe:   return u"legacyWireframe"_ustr;
        case XML_matte:             return u"matte"_ustr;
        case XML_plastic:           return u"plastic"_ustr;
        case XML_metal:             return u"metal"_ustr;
        case XML_warmMatte:         return u"warmMatte"_ustr;
        case XML_translucentPowder: return u"translucentPowder"_ustr;
        case XML_powder:            return u"powder"_ustr;
        case XML_dkEdge:            return u"dkEdge"_ustr;
        case XML_softEdge:          return u"softEdge"_ustr;
        case XML_clear:             return u"clear"_ustr;
        case XML_flat:              return u"flat"_ustr;
        case XML_softmetal:         return u"softmetal"_ustr;
        case XML_none:              return u"none"_ustr;
    }
    SAL_WARN( "oox.drawingml", "Generic3DProperties::getPresetMaterialTypeString - unexpected token" );
    return OUString();
}

css::uno::Sequence< css::beans::PropertyValue > Generic3DProperties::getCameraAttributes()
{
    css::uno::Sequence<css::beans::PropertyValue> aSeq(6);
    auto pSeq = aSeq.getArray();
    sal_Int32 nSize = 0;
    if( mfFieldOfVision.has_value() )
    {
        pSeq[nSize].Name = "fov";
        pSeq[nSize].Value <<= *mfFieldOfVision;
        nSize++;
    }
    if( mfZoom.has_value() )
    {
        pSeq[nSize].Name = "zoom";
        pSeq[nSize].Value <<= *mfZoom;
        nSize++;
    }
    if( mnPreset.has_value() )
    {
        pSeq[nSize].Name = "prst";
        pSeq[nSize].Value <<= getCameraPrstName( *mnPreset );
        nSize++;
    }
    if( maCameraRotation.mnLatitude.has_value() )
    {
        pSeq[nSize].Name = "rotLat";
        pSeq[nSize].Value <<= *maCameraRotation.mnLatitude;
        nSize++;
    }
    if( maCameraRotation.mnLongitude.has_value() )
    {
        pSeq[nSize].Name = "rotLon";
        pSeq[nSize].Value <<= *maCameraRotation.mnLongitude;
        nSize++;
    }
    if( maCameraRotation.mnRevolution.has_value() )
    {
        pSeq[nSize].Name = "rotRev";
        pSeq[nSize].Value <<= *maCameraRotation.mnRevolution;
        nSize++;
    }
    aSeq.realloc( nSize );
    return aSeq;
}

css::uno::Sequence< css::beans::PropertyValue > Generic3DProperties::getLightRigAttributes()
{
    css::uno::Sequence<css::beans::PropertyValue> aSeq(5);
    auto pSeq = aSeq.getArray();
    sal_Int32 nSize = 0;
    if( mnLightRigDirection.has_value() )
    {
        pSeq[nSize].Name = "dir";
        pSeq[nSize].Value <<= getLightRigDirName( *mnLightRigDirection );
        nSize++;
    }
    if( mnLightRigType.has_value() )
    {
        pSeq[nSize].Name = "rig";
        pSeq[nSize].Value <<= getLightRigName( *mnLightRigType );
        nSize++;
    }
    if( maLightRigRotation.mnLatitude.has_value() )
    {
        pSeq[nSize].Name = "rotLat";
        pSeq[nSize].Value <<= *maLightRigRotation.mnLatitude;
        nSize++;
    }
    if( maLightRigRotation.mnLongitude.has_value() )
    {
        pSeq[nSize].Name = "rotLon";
        pSeq[nSize].Value <<= *maLightRigRotation.mnLongitude;
        nSize++;
    }
    if( maLightRigRotation.mnRevolution.has_value() )
    {
        pSeq[nSize].Name = "rotRev";
        pSeq[nSize].Value <<= *maLightRigRotation.mnRevolution;
        nSize++;
    }
    aSeq.realloc( nSize );
    return aSeq;
}

css::uno::Sequence< css::beans::PropertyValue > Generic3DProperties::getBevelAttributes( BevelProperties rProps )
{
    css::uno::Sequence<css::beans::PropertyValue> aSeq(3);
    auto pSeq = aSeq.getArray();
    sal_Int32 nSize = 0;
    if( rProps.mnPreset.has_value() )
    {
        pSeq[nSize].Name = "prst";
        pSeq[nSize].Value <<= getBevelPresetTypeString( *rProps.mnPreset );
        nSize++;
    }
    if( rProps.mnWidth.has_value() )
    {
        pSeq[nSize].Name = "w";
        pSeq[nSize].Value <<= *rProps.mnWidth;
        nSize++;
    }
    if( rProps.mnHeight.has_value() )
    {
        pSeq[nSize].Name = "h";
        pSeq[nSize].Value <<= *rProps.mnHeight;
        nSize++;
    }
    aSeq.realloc( nSize );
    return aSeq;
}

css::uno::Sequence< css::beans::PropertyValue > Generic3DProperties::getColorAttributes(
        const Color& rColor, const GraphicHelper& rGraphicHelper, ::Color rPhClr )
{
    const OUString& sColorScheme = rColor.getSchemeColorName();
    if( sColorScheme.isEmpty() )
    {
        // RGB color and transparency value
        return { comphelper::makePropertyValue(u"rgbClr"_ustr, rColor.getColor( rGraphicHelper, rPhClr )),
                 comphelper::makePropertyValue(u"rgbClrTransparency"_ustr, rColor.getTransparency()) };
    }
    // scheme color with name and transformations
    return { comphelper::makePropertyValue(u"schemeClr"_ustr, sColorScheme),
             comphelper::makePropertyValue(u"schemeClrTransformations"_ustr,
                                           rColor.getTransformations()) };
}

css::uno::Sequence< css::beans::PropertyValue > Generic3DProperties::getShape3DAttributes(
        const GraphicHelper& rGraphicHelper, ::Color rPhClr )
{
    css::uno::Sequence<css::beans::PropertyValue> aSeq(8);
    auto pSeq = aSeq.getArray();
    sal_Int32 nSize = 0;
    if( mnExtrusionH.has_value() )
    {
        pSeq[nSize].Name = "extrusionH";
        pSeq[nSize].Value <<= *mnExtrusionH;
        nSize++;
    }
    if( mnContourW.has_value() )
    {
        pSeq[nSize].Name = "contourW";
        pSeq[nSize].Value <<= *mnContourW;
        nSize++;
    }
    if( mnShapeZ.has_value() )
    {
        pSeq[nSize].Name = "z";
        pSeq[nSize].Value <<= *mnShapeZ;
        nSize++;
    }
    if( mnMaterial.has_value() )
    {
        pSeq[nSize].Name = "prstMaterial";
        pSeq[nSize].Value <<= getPresetMaterialTypeString( *mnMaterial );
        nSize++;
    }
    if( maTopBevelProperties.has_value() )
    {
        pSeq[nSize].Name = "bevelT";
        pSeq[nSize].Value <<= getBevelAttributes( *maTopBevelProperties );
        nSize++;
    }
    if( maBottomBevelProperties.has_value() )
    {
        pSeq[nSize].Name = "bevelB";
        pSeq[nSize].Value <<= getBevelAttributes( *maBottomBevelProperties );
        nSize++;
    }
    if( maExtrusionColor.isUsed() )
    {
        pSeq[nSize].Name = "extrusionClr";
        pSeq[nSize].Value <<= getColorAttributes( maExtrusionColor, rGraphicHelper, rPhClr );
        nSize++;
    }
    if( maContourColor.isUsed() )
    {
        pSeq[nSize].Name = "contourClr";
        pSeq[nSize].Value <<= getColorAttributes( maContourColor, rGraphicHelper, rPhClr );
        nSize++;
    }
    aSeq.realloc( nSize );
    return aSeq;
}

} // namespace oox

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */