oox/source/drawingml/diagram/layoutnodecontext.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 "layoutnodecontext.hxx"
  21
  22 #include <oox/helper/attributelist.hxx>
  23 #include <oox/drawingml/shapecontext.hxx>
  24 #include <drawingml/customshapeproperties.hxx>
  25 #include "constraintlistcontext.hxx"
  26 #include "rulelistcontext.hxx"
  27 #include <oox/token/namespaces.hxx>
  28 #include <oox/token/tokens.hxx>
  29 #include <sal/log.hxx>
  30 #include <utility>
  31
  32 using namespace ::oox::core;
  33
  34 namespace oox::drawingml {
  35
  36 namespace {
  37
  38 class IfContext
  39     : public LayoutNodeContext
  40 {
  41 public:
  42     IfContext( ContextHandler2Helper const & rParent,
  43                const AttributeList& rAttribs,
  44                const ConditionAtomPtr& pAtom )
  45         : LayoutNodeContext( rParent, rAttribs, pAtom )
  46     {}
  47 };
  48
  49 class AlgorithmContext
  50     : public ContextHandler2
  51 {
  52 public:
  53     AlgorithmContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, const AlgAtomPtr & pNode )
  54         : ContextHandler2( rParent )
  55         , mnRevision( 0 )
  56         , mpNode( pNode )
  57         {
  58             mnRevision = rAttribs.getInteger( XML_rev, 0 );
  59             pNode->setType(rAttribs.getToken(XML_type, 0));
  60         }
  61
  62     virtual ContextHandlerRef
  63     onCreateContext( ::sal_Int32 aElement,
  64                      const AttributeList& rAttribs ) override
  65         {
  66             switch( aElement )
  67             {
  68                 case DGM_TOKEN( param ):
  69                 {
  70                     sal_Int32 nType = rAttribs.getToken(XML_type, 0);
  71                     switch (nType)
  72                     {
  73                         case XML_ar:
  74                             mpNode->setAspectRatio(rAttribs.getDouble(XML_val, 0));
  75                             break;
  76                         default:
  77                             const sal_Int32 nValTok = rAttribs.getToken(XML_val, 0);
  78                             mpNode->addParam(nType, nValTok > 0 ? nValTok
  79                                                                 : rAttribs.getInteger(XML_val, 0));
  80                             break;
  81                     }
  82                     break;
  83                 }
  84                 default:
  85                     break;
  86             }
  87
  88             return this;
  89         }
  90
  91 private:
  92     sal_Int32  mnRevision;
  93     AlgAtomPtr mpNode;
  94 };
  95
  96 class ChooseContext
  97     : public ContextHandler2
  98 {
  99 public:
 100     ChooseContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, LayoutAtomPtr pNode )
 101         : ContextHandler2( rParent )
 102         , mpNode(std::move( pNode ))
 103         {
 104             msName = rAttribs.getStringDefaulted( XML_name );
 105         }
 106
 107     virtual ContextHandlerRef
 108     onCreateContext( ::sal_Int32 aElement,
 109                      const AttributeList& rAttribs ) override
 110         {
 111             switch( aElement )
 112             {
 113             case DGM_TOKEN( if ):
 114             {
 115                 // CT_When
 116                 ConditionAtomPtr pNode = std::make_shared<ConditionAtom>(mpNode->getLayoutNode(), false, rAttribs.getFastAttributeList());
 117                 LayoutAtom::connect(mpNode, pNode);
 118                 return new IfContext( *this, rAttribs, pNode );
 119             }
 120             case DGM_TOKEN( else ):
 121             {
 122                 // CT_Otherwise
 123                 ConditionAtomPtr pNode = std::make_shared<ConditionAtom>(mpNode->getLayoutNode(), true, rAttribs.getFastAttributeList());
 124                 LayoutAtom::connect(mpNode, pNode);
 125                 return new IfContext( *this, rAttribs, pNode );
 126             }
 127             default:
 128                 break;
 129             }
 130
 131             return this;
 132         }
 133 private:
 134     OUString msName;
 135     LayoutAtomPtr mpNode;
 136 };
 137
 138 class ForEachContext
 139     : public LayoutNodeContext
 140 {
 141 public:
 142     ForEachContext( ContextHandler2Helper const & rParent, const AttributeList& rAttribs, const ForEachAtomPtr& pAtom )
 143         : LayoutNodeContext( rParent, rAttribs, pAtom )
 144         {
 145             pAtom->setRef(rAttribs.getStringDefaulted(XML_ref));
 146             pAtom->iterator().loadFromXAttr( rAttribs.getFastAttributeList() );
 147
 148             LayoutAtomMap& rLayoutAtomMap = pAtom->getLayoutNode().getDiagram().getLayout()->getLayoutAtomMap();
 149             rLayoutAtomMap[pAtom->getName()] = pAtom;
 150         }
 151 };
 152
 153 // CT_LayoutVariablePropertySet
 154 class LayoutVariablePropertySetContext
 155     : public ContextHandler2
 156 {
 157 public:
 158     LayoutVariablePropertySetContext( ContextHandler2Helper const & rParent, LayoutNode::VarMap & aVar )
 159         : ContextHandler2( rParent )
 160         , mVariables( aVar )
 161         {
 162         }
 163
 164     virtual ContextHandlerRef onCreateContext( ::sal_Int32 aElement, const AttributeList& rAttribs ) override
 165         {
 166             mVariables[ getBaseToken(aElement) ] = rAttribs.getStringDefaulted( XML_val );
 167             return this;
 168         }
 169 private:
 170     LayoutNode::VarMap & mVariables;
 171 };
 172
 173 }
 174
 175 // CT_LayoutNode
 176 LayoutNodeContext::LayoutNodeContext( ContextHandler2Helper const & rParent,
 177                                       const AttributeList& rAttribs,
 178                                       const LayoutAtomPtr& pAtom )
 179     : ContextHandler2( rParent )
 180     , mpNode( pAtom )
 181 {
 182     assert( pAtom && "Node must NOT be NULL" );
 183     mpNode->setName( rAttribs.getStringDefaulted( XML_name ) );
 184 }
 185
 186 LayoutNodeContext::~LayoutNodeContext()
 187 {
 188 }
 189
 190 ContextHandlerRef
 191 LayoutNodeContext::onCreateContext( ::sal_Int32 aElement,
 192                                     const AttributeList& rAttribs )
 193 {
 194     switch( aElement )
 195     {
 196     case DGM_TOKEN( layoutNode ):
 197     {
 198         LayoutNodePtr pNode = std::make_shared<LayoutNode>(mpNode->getLayoutNode().getDiagram());
 199         LayoutAtom::connect(mpNode, pNode);
 200
 201         if (rAttribs.hasAttribute(XML_chOrder))
 202         {
 203             pNode->setChildOrder(rAttribs.getToken(XML_chOrder, XML_b));
 204         }
 205         else
 206         {
 207             for (LayoutAtomPtr pAtom = mpNode; pAtom; pAtom = pAtom->getParent())
 208             {
 209                 auto pLayoutNode = dynamic_cast<LayoutNode*>(pAtom.get());
 210                 if (pLayoutNode)
 211                 {
 212                     pNode->setChildOrder(pLayoutNode->getChildOrder());
 213                     break;
 214                 }
 215             }
 216         }
 217
 218         pNode->setMoveWith( rAttribs.getStringDefaulted( XML_moveWith ) );
 219         pNode->setStyleLabel( rAttribs.getStringDefaulted( XML_styleLbl ) );
 220         return new LayoutNodeContext( *this, rAttribs, pNode );
 221     }
 222     case DGM_TOKEN( shape ):
 223     {
 224         ShapePtr pShape;
 225
 226         if( rAttribs.hasAttribute( XML_type ) )
 227         {
 228             pShape = std::make_shared<Shape>("com.sun.star.drawing.CustomShape");
 229             if (!rAttribs.getBool(XML_hideGeom, false))
 230             {
 231                 const sal_Int32 nType(rAttribs.getToken( XML_type, XML_obj ));
 232                 pShape->setSubType( nType );
 233                 pShape->getCustomShapeProperties()->setShapePresetType( nType );
 234             }
 235         }
 236         else
 237         {
 238             pShape = std::make_shared<Shape>("com.sun.star.drawing.GroupShape");
 239         }
 240
 241         pShape->setDiagramRotation(rAttribs.getInteger(XML_rot, 0) * PER_DEGREE);
 242
 243         pShape->setZOrderOff(rAttribs.getInteger(XML_zOrderOff, 0));
 244
 245         ShapeAtomPtr pAtom = std::make_shared<ShapeAtom>(mpNode->getLayoutNode(), pShape);
 246         LayoutAtom::connect(mpNode, pAtom);
 247         return new ShapeContext( *this, ShapePtr(), std::move(pShape) );
 248     }
 249     case DGM_TOKEN( extLst ):
 250         return nullptr;
 251     case DGM_TOKEN( alg ):
 252     {
 253         // CT_Algorithm
 254         AlgAtomPtr pAtom = std::make_shared<AlgAtom>(mpNode->getLayoutNode());
 255         LayoutAtom::connect(mpNode, pAtom);
 256         return new AlgorithmContext( *this, rAttribs, pAtom );
 257     }
 258     case DGM_TOKEN( choose ):
 259     {
 260         // CT_Choose
 261         LayoutAtomPtr pAtom = std::make_shared<ChooseAtom>(mpNode->getLayoutNode());
 262         LayoutAtom::connect(mpNode, pAtom);
 263         return new ChooseContext( *this, rAttribs, std::move(pAtom) );
 264     }
 265     case DGM_TOKEN( forEach ):
 266     {
 267         // CT_ForEach
 268         ForEachAtomPtr pAtom = std::make_shared<ForEachAtom>(mpNode->getLayoutNode(), rAttribs.getFastAttributeList());
 269         LayoutAtom::connect(mpNode, pAtom);
 270         return new ForEachContext( *this, rAttribs, pAtom );
 271     }
 272     case DGM_TOKEN( constrLst ):
 273         // CT_Constraints
 274         return new ConstraintListContext( *this, mpNode );
 275     case DGM_TOKEN( presOf ):
 276     {
 277         // CT_PresentationOf
 278         // TODO
 279         IteratorAttr aIterator;
 280         aIterator.loadFromXAttr(rAttribs.getFastAttributeList());
 281         break;
 282     }
 283     case DGM_TOKEN( ruleLst ):
 284         // CT_Rules
 285         return new RuleListContext( *this, mpNode );
 286     case DGM_TOKEN( varLst ):
 287     {
 288         LayoutNodePtr pNode(std::dynamic_pointer_cast<LayoutNode>(mpNode));
 289         if( pNode )
 290         {
 291             return new LayoutVariablePropertySetContext( *this, pNode->variables() );
 292         }
 293         else
 294         {
 295             SAL_WARN("oox",  "OOX: encountered a varLst in a non layoutNode context" );
 296         }
 297         break;
 298     }
 299     default:
 300         break;
 301     }
 302
 303     return this;
 304 }
 305
 306 }
 307
 308 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */