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 "drawingml/diagram/diagram.hxx"
  24 #include "oox/drawingml/shapecontext.hxx"
  25 #include "drawingml/customshapeproperties.hxx"
  26 #include "diagramdefinitioncontext.hxx"
  27 #include "constraintlistcontext.hxx"
  28 #include <oox/token/namespaces.hxx>
  29 #include <oox/token/tokens.hxx>
  30 #include <osl/diagnose.h>
  31
  32 using namespace ::oox::core;
  33 using namespace ::com::sun::star::uno;
  34 using namespace ::com::sun::star::xml::sax;
  35
  36 namespace oox { namespace drawingml {
  37
  38 class IfContext
  39     : public LayoutNodeContext
  40 {
  41 public:
  42     IfContext( ContextHandler2Helper& 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& 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                     const sal_Int32 nValTok = rAttribs.getToken( XML_val, 0 );
  71                     mpNode->addParam(
  72                         rAttribs.getToken( XML_type, 0 ),
  73                         nValTok>0 ? nValTok : rAttribs.getInteger( XML_val, 0 ) );
  74                     break;
  75                 }
  76                 default:
  77                     break;
  78             }
  79
  80             return this;
  81         }
  82
  83 private:
  84     sal_Int32  mnRevision;
  85     AlgAtomPtr mpNode;
  86 };
  87
  88 class ChooseContext
  89     : public ContextHandler2
  90 {
  91 public:
  92     ChooseContext( ContextHandler2Helper& rParent, const AttributeList& rAttribs, const LayoutAtomPtr & pNode )
  93         : ContextHandler2( rParent )
  94         , mpNode( pNode )
  95         {
  96             msName = rAttribs.getString( XML_name ).get();
  97         }
  98
  99     virtual ContextHandlerRef
 100     onCreateContext( ::sal_Int32 aElement,
 101                      const AttributeList& rAttribs ) override
 102         {
 103             switch( aElement )
 104             {
 105             case DGM_TOKEN( if ):
 106             {
 107                 // CT_When
 108                 mpConditionNode.reset( new ConditionAtom(rAttribs.getFastAttributeList()) );
 109                 mpNode->addChild( mpConditionNode );
 110                 return new IfContext( *this, rAttribs, mpConditionNode );
 111             }
 112             case DGM_TOKEN( else ):
 113                 // CT_Otherwise
 114                 if( mpConditionNode )
 115                 {
 116                     mpConditionNode->readElseBranch();
 117                     ContextHandlerRef xRet = new IfContext( *this, rAttribs, mpConditionNode );
 118                     mpConditionNode.reset();
 119                     return xRet;
 120                 }
 121                 else
 122                 {
 123                     SAL_WARN("oox",  "ignoring second else clause" );
 124                 }
 125                 break;
 126             default:
 127                 break;
 128             }
 129
 130             return this;
 131         }
 132 private:
 133     OUString msName;
 134     LayoutAtomPtr mpNode;
 135     ConditionAtomPtr mpConditionNode;
 136 };
 137
 138 class ForEachContext
 139     : public LayoutNodeContext
 140 {
 141 public:
 142     ForEachContext( ContextHandler2Helper& rParent, const AttributeList& rAttribs, const ForEachAtomPtr& pAtom )
 143         : LayoutNodeContext( rParent, rAttribs, pAtom )
 144         {
 145             rAttribs.getString( XML_ref );
 146             pAtom->iterator().loadFromXAttr( rAttribs.getFastAttributeList() );
 147         }
 148 };
 149
 150 // CT_LayoutVariablePropertySet
 151 class LayoutVariablePropertySetContext
 152     : public ContextHandler2
 153 {
 154 public:
 155     LayoutVariablePropertySetContext( ContextHandler2Helper& rParent, LayoutNode::VarMap & aVar )
 156         : ContextHandler2( rParent )
 157         , mVariables( aVar )
 158         {
 159         }
 160
 161     virtual ContextHandlerRef onCreateContext( ::sal_Int32 aElement, const AttributeList& rAttribs ) override
 162         {
 163             sal_Int32 nIdx =  LayoutNodeContext::tagToVarIdx( getBaseToken( aElement ) );
 164             if( nIdx != -1 )
 165             {
 166                 mVariables[ nIdx ] <<= rAttribs.getString( XML_val ).get();
 167             }
 168
 169             return this;
 170         }
 171 private:
 172     LayoutNode::VarMap & mVariables;
 173 };
 174
 175 // CT_LayoutNode
 176 LayoutNodeContext::LayoutNodeContext( ContextHandler2Helper& rParent,
 177                                       const AttributeList& rAttribs,
 178                                       const LayoutAtomPtr& pAtom )
 179     : ContextHandler2( rParent )
 180     , mpNode( pAtom )
 181 {
 182     OSL_ENSURE( pAtom, "Node must NOT be NULL" );
 183     mpNode->setName( rAttribs.getString( XML_name ).get() );
 184 }
 185
 186 LayoutNodeContext::~LayoutNodeContext()
 187 {
 188 }
 189
 190 /** convert the XML tag to a variable index in the array
 191  * @param aTag the tag, without namespace
 192  * @return the variable index. -1 is an error
 193  */
 194 sal_Int32 LayoutNodeContext::tagToVarIdx( sal_Int32 aTag )
 195 {
 196     sal_Int32 nIdx = -1;
 197     switch( aTag )
 198     {
 199     case DGM_TOKEN( animLvl ):
 200         nIdx = LayoutNode::VAR_animLvl;
 201         break;
 202     case DGM_TOKEN( animOne ):
 203         nIdx = LayoutNode::VAR_animOne;
 204         break;
 205     case DGM_TOKEN( bulletEnabled ):
 206         nIdx = LayoutNode::VAR_bulletEnabled;
 207         break;
 208     case DGM_TOKEN( chMax ):
 209         nIdx = LayoutNode::VAR_chMax;
 210         break;
 211     case DGM_TOKEN( chPref ):
 212         nIdx = LayoutNode::VAR_chPref;
 213         break;
 214     case DGM_TOKEN( dir ):
 215         nIdx = LayoutNode::VAR_dir;
 216         break;
 217     case DGM_TOKEN( hierBranch ):
 218         nIdx = LayoutNode::VAR_hierBranch;
 219         break;
 220     case DGM_TOKEN( orgChart ):
 221         nIdx = LayoutNode::VAR_orgChart;
 222         break;
 223     case DGM_TOKEN( resizeHandles ):
 224         nIdx = LayoutNode::VAR_resizeHandles;
 225         break;
 226     default:
 227         break;
 228     }
 229     return nIdx;
 230 }
 231
 232 ContextHandlerRef
 233 LayoutNodeContext::onCreateContext( ::sal_Int32 aElement,
 234                                     const AttributeList& rAttribs )
 235 {
 236     switch( aElement )
 237     {
 238     case DGM_TOKEN( layoutNode ):
 239     {
 240         LayoutNodePtr pNode( new LayoutNode() );
 241         mpNode->addChild( pNode );
 242         pNode->setChildOrder( rAttribs.getToken( XML_chOrder, XML_b ) );
 243         pNode->setMoveWith( rAttribs.getString( XML_moveWith ).get() );
 244         pNode->setStyleLabel( rAttribs.getString( XML_styleLbl ).get() );
 245         return new LayoutNodeContext( *this, rAttribs, pNode );
 246     }
 247     case DGM_TOKEN( shape ):
 248     {
 249         LayoutNodePtr pNode(std::dynamic_pointer_cast<LayoutNode>(mpNode));
 250         if( pNode )
 251         {
 252             ShapePtr pShape;
 253
 254             if( rAttribs.hasAttribute( XML_type ) )
 255             {
 256                 pShape.reset( new Shape("com.sun.star.drawing.CustomShape") );
 257                 const sal_Int32 nType(rAttribs.getToken( XML_type, XML_obj ));
 258                 pShape->setSubType( nType );
 259                 pShape->getCustomShapeProperties()->setShapePresetType( nType );
 260             }
 261             else
 262             {
 263                 pShape.reset( new Shape("com.sun.star.drawing.GroupShape") );
 264             }
 265
 266             pNode->setShape( pShape );
 267             return new ShapeContext( *this, ShapePtr(), pShape );
 268         }
 269         else
 270         {
 271             SAL_WARN("oox",  "OOX: encountered a shape in a non layoutNode context" );
 272         }
 273         break;
 274     }
 275     case DGM_TOKEN( extLst ):
 276         return nullptr;
 277     case DGM_TOKEN( alg ):
 278     {
 279         // CT_Algorithm
 280         AlgAtomPtr pAtom( new AlgAtom );
 281         mpNode->addChild( pAtom );
 282         return new AlgorithmContext( *this, rAttribs, pAtom );
 283     }
 284     case DGM_TOKEN( choose ):
 285     {
 286         // CT_Choose
 287         LayoutAtomPtr pAtom( new ChooseAtom );
 288         mpNode->addChild( pAtom );
 289         return new ChooseContext( *this, rAttribs, pAtom );
 290     }
 291     case DGM_TOKEN( forEach ):
 292     {
 293         // CT_ForEach
 294         ForEachAtomPtr pAtom( new ForEachAtom(rAttribs.getFastAttributeList()) );
 295         mpNode->addChild( pAtom );
 296         return new ForEachContext( *this, rAttribs, pAtom );
 297     }
 298     case DGM_TOKEN( constrLst ):
 299         // CT_Constraints
 300         return new ConstraintListContext( *this, mpNode );
 301     case DGM_TOKEN( presOf ):
 302     {
 303         // CT_PresentationOf
 304         // TODO
 305         rAttribs.getString( XML_axis );
 306         rAttribs.getString( XML_cnt );
 307         rAttribs.getString( XML_hideLastTrans );
 308         rAttribs.getString( XML_ptType );
 309         rAttribs.getString( XML_st );
 310         rAttribs.getString( XML_step );
 311         break;
 312     }
 313     case DGM_TOKEN( ruleLst ):
 314         // CT_Rules
 315         // TODO
 316         break;
 317     case DGM_TOKEN( varLst ):
 318     {
 319         LayoutNodePtr pNode(std::dynamic_pointer_cast<LayoutNode>(mpNode));
 320         if( pNode )
 321         {
 322             return new LayoutVariablePropertySetContext( *this, pNode->variables() );
 323         }
 324         else
 325         {
 326             SAL_WARN("oox",  "OOX: encountered a varLst in a non layoutNode context" );
 327         }
 328         break;
 329     }
 330     default:
 331         break;
 332     }
 333
 334     return this;
 335 }
 336
 337 } }
 338
 339 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */