1321 lines
46 KiB
C++
1321 lines
46 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
#include "entrance.h"
|
|
|
|
#include "common.h"
|
|
|
|
#include "../../DesktopEditor/common/File.h"
|
|
#include "../../DesktopEditor/common/Directory.h"
|
|
#include "../../OfficeUtils/src/OfficeUtils.h"
|
|
|
|
#include "Writer/Converter/Converter.h"
|
|
#include "Writer/Converter/PptxConverter.h"
|
|
#include "Writer/Format/office_elements.h"
|
|
|
|
boost::shared_ptr<cpdoccore::oox::pptx_conversion_context> ODP2OOX_AnimationEntranceEnvironment::sConverionContext;
|
|
boost::shared_ptr<cpdoccore::odf_reader::odf_document> ODP2OOX_AnimationEntranceEnvironment::sInputOdf;
|
|
|
|
ODP2OOX_AnimationEntranceEnvironment::ODP2OOX_AnimationEntranceEnvironment()
|
|
: ODP2OOX_AnimationEnvironment(
|
|
L"ExampleFiles" FILE_SEPARATOR_STR "entrance.odp",
|
|
&sInputOdf,
|
|
&sConverionContext)
|
|
{
|
|
|
|
}
|
|
|
|
const cpdoccore::oox::pptx_animation_context& ODP2OOX_AnimationEntranceEnvironment::GetAnimationContext()
|
|
{
|
|
return sConverionContext->get_slide_context().get_animation_context();
|
|
}
|
|
|
|
void ODP2OOX_EntranceAnimationTest::SetUp()
|
|
{
|
|
mAnimationContext = &ODP2OOX_AnimationEntranceEnvironment::GetAnimationContext();
|
|
}
|
|
|
|
const cpdoccore::oox::pptx_animation_context::Impl::_par_animation_ptr& ODP2OOX_EntranceAnimationTest::GetInnerPar(const cpdoccore::oox::pptx_animation_context::Impl::_par_animation_ptr& par)
|
|
{
|
|
return par->AnimParArray[0];
|
|
}
|
|
|
|
const cpdoccore::oox::pptx_animation_context::Impl::_seq_animation_ptr& ODP2OOX_EntranceAnimationTest::GetMainSequence()
|
|
{
|
|
if(mAnimationContext->get_root_par_animation()->AnimSeq.size())
|
|
return mAnimationContext->get_root_par_animation()->AnimSeq[0];
|
|
return nullptr;
|
|
}
|
|
|
|
const cpdoccore::oox::pptx_animation_context::Impl::_par_animation_array& ODP2OOX_EntranceAnimationTest::GetMainSequenceArray()
|
|
{
|
|
return mAnimationContext->get_root_par_animation()->AnimSeq[0]->AnimParArray;
|
|
}
|
|
|
|
const cpdoccore::oox::pptx_animation_context::Impl::_animation_element_array& ODP2OOX_EntranceAnimationTest::GetActionArray(const cpdoccore::oox::pptx_animation_context::Impl::_par_animation_ptr& par)
|
|
{
|
|
return par->AnimationActionArray;
|
|
}
|
|
|
|
const cpdoccore::oox::pptx_animation_context::Impl::_par_animation_ptr ODP2OOX_EntranceAnimationTest::GetInnermostPar(const cpdoccore::oox::pptx_animation_context::Impl::_par_animation_ptr& par)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
cpdoccore::oox::pptx_animation_context::Impl::_par_animation_ptr inner = par;
|
|
|
|
while (inner->AnimParArray.size())
|
|
{
|
|
inner = GetInnerPar(inner);
|
|
}
|
|
|
|
return inner;
|
|
}
|
|
|
|
const cpdoccore::oox::pptx_animation_context::Impl::_animation_element_array& ODP2OOX_EntranceAnimationTest::GetAnimationActionsByIndex(size_t index)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const pptx_animation_context::Impl::_par_animation_array& main_seq = GetMainSequenceArray();
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetInnermostPar(main_seq[index])->AnimationActionArray;
|
|
|
|
return actions;
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, timing_root_par)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const pptx_animation_context::Impl::_par_animation_ptr& root = mAnimationContext->get_root_par_animation();
|
|
|
|
const std::wstring nodeTypeExp = L"tmRoot";
|
|
|
|
EXPECT_EQ(root->NodeType.value(), nodeTypeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, main_sequence)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const pptx_animation_context::Impl::_seq_animation_ptr& main_seq = GetMainSequence();
|
|
|
|
const std::wstring nodeTypeExp = L"mainSeq";
|
|
|
|
EXPECT_EQ(main_seq->PresentationNodeType.value(), nodeTypeExp);
|
|
EXPECT_FALSE(main_seq->Duration.has_value());
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, main_sequence_par_animations)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const pptx_animation_context::Impl::_par_animation_array& par_animations = mAnimationContext->get_root_par_animation()->AnimSeq[0]->AnimParArray;
|
|
|
|
const std::wstring delayExp = L"indefinite";
|
|
|
|
for (size_t i = 0; i < par_animations.size(); i++)
|
|
{
|
|
EXPECT_EQ(par_animations[i]->Delay.value(), delayExp);
|
|
}
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, main_sequence_inner_par_animation)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const pptx_animation_context::Impl::_par_animation_array& main_seq = GetMainSequenceArray();
|
|
|
|
std::wstring delayExp = L"0";
|
|
|
|
for (size_t i = 0; i < main_seq.size(); i++)
|
|
{
|
|
const pptx_animation_context::Impl::_par_animation_ptr& par = GetInnerPar(main_seq[i]);
|
|
|
|
EXPECT_EQ(par->Delay.value(), delayExp);
|
|
}
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, main_sequence_innermost_par_animation)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const pptx_animation_context::Impl::_par_animation_array& main_seq = GetMainSequenceArray();
|
|
|
|
std::wstring delayExp = L"0";
|
|
std::wstring fillExp = L"hold";
|
|
std::wstring nodeTypeExp = L"clickEffect";
|
|
std::wstring presetClassExp = L"entr";
|
|
|
|
for (size_t i = 0; i < main_seq.size(); i++)
|
|
{
|
|
const pptx_animation_context::Impl::_par_animation_ptr& par = GetInnermostPar(main_seq[i]);
|
|
|
|
EXPECT_EQ(par->Delay.value(), delayExp);
|
|
EXPECT_EQ(par->Fill.value(), fillExp);
|
|
EXPECT_EQ(par->NodeType.value(), nodeTypeExp);
|
|
EXPECT_EQ(par->PresetClass.value(), presetClassExp);
|
|
}
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_appear_acitons_size)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 0;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const size_t actionsSizeExp = 1;
|
|
|
|
EXPECT_EQ(actions.size(), actionsSizeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, enerance_appear_actions_set)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 0;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
EXPECT_TRUE(set != nullptr);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, enerance_appear_action_set_duration)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 0;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
const int durationExp = 1;
|
|
|
|
EXPECT_EQ(set->Duration.value(), durationExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, enerance_appear_action_set_fill)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 0;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
const std::wstring fillExp = L"hold";
|
|
|
|
EXPECT_EQ(set->Fill.value(), fillExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, enerance_appear_action_set_delay)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 0;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
const std::wstring fillExp = L"hold";
|
|
|
|
EXPECT_EQ(set->Fill.value(), fillExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, enerance_appear_action_set_attribute_name)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 0;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
const std::wstring attributeNameExp = L"style.visibility";
|
|
|
|
EXPECT_EQ(set->AttributeName.value(), attributeNameExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, enerance_appear_action_set_to_value)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 0;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
const std::wstring toValueExp = L"visible";
|
|
|
|
EXPECT_EQ(set->ToValue.value(), toValueExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_actions_size)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const size_t actionsSizeExp = 3;
|
|
|
|
EXPECT_EQ(actions.size(), actionsSizeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_set)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
EXPECT_TRUE(set != nullptr);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_1)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate1 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[1].get());
|
|
|
|
EXPECT_TRUE(animate1 != nullptr);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_2)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate2 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[2].get());
|
|
|
|
EXPECT_TRUE(animate2 != nullptr);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_set_duration)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
const int durationExp = 1;
|
|
|
|
EXPECT_EQ(set->Duration.value(), durationExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_set_delay)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
const std::wstring delayExp = L"0";
|
|
|
|
EXPECT_EQ(set->Delay.value(), delayExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_set_fill)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
const std::wstring fillExp = L"hold";
|
|
|
|
EXPECT_EQ(set->Fill.value(), fillExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_set_attribute_name)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
const std::wstring attributeNameExp = L"style.visibility";
|
|
|
|
EXPECT_EQ(set->AttributeName.value(), attributeNameExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_set_to_value)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
const std::wstring toValueExp = L"visible";
|
|
|
|
EXPECT_EQ(set->ToValue.value(), toValueExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_1_calc_mode)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate1 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[1].get());
|
|
const std::wstring calcModeExp = L"lin";
|
|
|
|
EXPECT_EQ(animate1->CalcMode.value(), calcModeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_1_value_type)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate1 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[1].get());
|
|
const std::wstring valueTypeExp = L"num";
|
|
|
|
EXPECT_EQ(animate1->ValueType.value(), valueTypeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_1_duration)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate1 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[1].get());
|
|
const int durationExp = 500;
|
|
|
|
EXPECT_EQ(animate1->Duration.value(), durationExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_1_attribute_name)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate1 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[1].get());
|
|
const std::wstring attributeNameExp = L"ppt_x";
|
|
|
|
EXPECT_EQ(animate1->AttributeName.value(), attributeNameExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_1_additive)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate1 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[1].get());
|
|
const std::wstring additiveExp = L"repl";
|
|
|
|
EXPECT_EQ(animate1->Additive.value(), additiveExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_1_key_points)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate1 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[1].get());
|
|
std::vector<pptx_animation_context::Impl::_anim::_keypoint> keypointsExp;
|
|
keypointsExp.push_back(pptx_animation_context::Impl::_anim::_keypoint(0, L"ppt_x", boost::none));
|
|
keypointsExp.push_back(pptx_animation_context::Impl::_anim::_keypoint(100000, L"ppt_x", boost::none));
|
|
|
|
EXPECT_EQ(animate1->KeypointArray->size(), keypointsExp.size());
|
|
for (size_t i = 0; i < animate1->KeypointArray->size(); i++)
|
|
{
|
|
EXPECT_EQ(animate1->KeypointArray->at(i).Time, keypointsExp[i].Time);
|
|
EXPECT_EQ(animate1->KeypointArray->at(i).Value, keypointsExp[i].Value);
|
|
EXPECT_EQ(animate1->KeypointArray->at(i).Fmla.has_value(), keypointsExp[i].Fmla.has_value());
|
|
EXPECT_EQ(animate1->KeypointArray->at(i).Fmla.value_or(L""), keypointsExp[i].Fmla.value_or(L""));
|
|
}
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_2_calc_mode)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate2 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[2].get());
|
|
const std::wstring calcModeExp = L"lin";
|
|
|
|
EXPECT_EQ(animate2->CalcMode.value(), calcModeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_2_value_type)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate2 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[2].get());
|
|
const std::wstring valueTypeExp = L"num";
|
|
|
|
EXPECT_EQ(animate2->ValueType.value(), valueTypeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_2_duration)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate2 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[2].get());
|
|
const int durationExp = 500;
|
|
|
|
EXPECT_EQ(animate2->Duration.value(), durationExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_2_attribute_name)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate2 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[2].get());
|
|
const std::wstring attributeNameExp = L"ppt_y";
|
|
|
|
EXPECT_EQ(animate2->AttributeName.value(), attributeNameExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_2_additive)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate2 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[2].get());
|
|
const std::wstring additiveExp = L"repl";
|
|
|
|
EXPECT_EQ(animate2->Additive.value(), additiveExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_fly_in_action_animate_2_key_points)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 1;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const pptx_animation_context::Impl::_anim* animate2 = dynamic_cast<pptx_animation_context::Impl::_anim*>(actions[2].get());
|
|
std::vector<pptx_animation_context::Impl::_anim::_keypoint> keypointsExp;
|
|
keypointsExp.push_back(pptx_animation_context::Impl::_anim::_keypoint(0, L"1+ppt_h/2", boost::none));
|
|
keypointsExp.push_back(pptx_animation_context::Impl::_anim::_keypoint(100000, L"ppt_y", boost::none));
|
|
|
|
EXPECT_EQ(animate2->KeypointArray->size(), keypointsExp.size());
|
|
for (size_t i = 0; i < animate2->KeypointArray->size(); i++)
|
|
{
|
|
EXPECT_EQ(animate2->KeypointArray->at(i).Time, keypointsExp[i].Time);
|
|
EXPECT_EQ(animate2->KeypointArray->at(i).Value, keypointsExp[i].Value);
|
|
EXPECT_EQ(animate2->KeypointArray->at(i).Fmla.has_value(), keypointsExp[i].Fmla.has_value());
|
|
EXPECT_EQ(animate2->KeypointArray->at(i).Fmla.value_or(L""), keypointsExp[i].Fmla.value_or(L""));
|
|
}
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_venetian_blinds_actions_size)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 2;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
|
|
const size_t actionsSizeExp = 2;
|
|
|
|
EXPECT_EQ(actions.size(), actionsSizeExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_venetian_blinds_set)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 2;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_set* set = dynamic_cast<pptx_animation_context::Impl::_set*>(actions[0].get());
|
|
|
|
EXPECT_TRUE(set != nullptr);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_venetian_blinds_anim_effect)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 2;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
EXPECT_TRUE(animEffect != nullptr);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_venetian_blinds_anim_effect_filter)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 2;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
const std::wstring filterExp = L"blinds(horizontal)";
|
|
|
|
EXPECT_EQ(animEffect->Filter.value(), filterExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_venetian_blinds_anim_effect_transition)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 2;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
EXPECT_FALSE(animEffect->Transition.has_value());
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_venetian_blinds_anim_effect_duration)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 2;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
const int durationExp = 500;
|
|
|
|
EXPECT_EQ(animEffect->Duration.value(), durationExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_transition_filter_blinds_wipe_horizontal)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 2;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
const std::wstring filterExp = L"blinds(horizontal)";
|
|
|
|
EXPECT_EQ(animEffect->Filter.value(), filterExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_transition_filter_iris_wipe_rectangle)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 3;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
const std::wstring filterExp = L"box(in)";
|
|
|
|
EXPECT_EQ(animEffect->Filter.value(), filterExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_transition_filter_checker_board_wipe_across)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 4;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
const std::wstring filterExp = L"checkerboard(across)";
|
|
|
|
EXPECT_EQ(animEffect->Filter.value(), filterExp);
|
|
}
|
|
|
|
TEST_F(ODP2OOX_EntranceAnimationTest, entrance_transition_filter_checker_iris_wipe_diamond)
|
|
{
|
|
using namespace cpdoccore::oox;
|
|
const size_t animationIndex = 8;
|
|
const pptx_animation_context::Impl::_animation_element_array& actions = GetAnimationActionsByIndex(animationIndex);
|
|
const pptx_animation_context::Impl::_anim_effect* animEffect = dynamic_cast<pptx_animation_context::Impl::_anim_effect*>(actions[1].get());
|
|
|
|
const std::wstring filterExp = L"diamond(in)";
|
|
|
|
EXPECT_EQ(animEffect->Filter.value(), filterExp);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// OOX2ODP
|
|
|
|
boost::shared_ptr<Oox2Odf::Converter> OOX2ODP_EntranceAnimationEnvironment::mConverter;
|
|
cpdoccore::odf_writer::odp_conversion_context* OOX2ODP_EntranceAnimationEnvironment::mContext;
|
|
|
|
OOX2ODP_EntranceAnimationEnvironment::OOX2ODP_EntranceAnimationEnvironment()
|
|
: OOX2ODP_AnimationEnvironment(L"entrance.pptx", &mConverter, &mContext)
|
|
{
|
|
}
|
|
|
|
cpdoccore::odf_writer::odp_conversion_context* OOX2ODP_EntranceAnimationEnvironment::GetContext()
|
|
{
|
|
return mContext;
|
|
}
|
|
|
|
void OOX2ODP_EntranceAnimationTest::SetUp()
|
|
{
|
|
mContext = OOX2ODP_EntranceAnimationEnvironment::GetContext();
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, timing_root_node_type)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* timing_root = GetTimingRoot();
|
|
ASSERT_NE(timing_root, nullptr);
|
|
|
|
const presentation_node_type NodeTypeExp = presentation_node_type::timing_root;
|
|
|
|
EXPECT_EQ(timing_root->attlist_.presentation_node_type_->get_type(), NodeTypeExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, main_sequence_node_type)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_seq* main_sequence = GetMainSequence();
|
|
ASSERT_NE(main_sequence, nullptr);
|
|
|
|
const presentation_node_type nodeTypeExp = presentation_node_type::main_sequence;
|
|
|
|
EXPECT_EQ(main_sequence->attlist_.presentation_node_type_->get_type(), nodeTypeExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, main_sequence_duration)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_seq* main_sequence = GetMainSequence();
|
|
ASSERT_NE(main_sequence, nullptr);
|
|
|
|
const odf_types::clockvalue durationExp(-1);
|
|
|
|
EXPECT_EQ(main_sequence->attlist_.smil_dur_->get_value(), durationExp.get_value());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_outer_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(0);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"next";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.get_value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_outer_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(0);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_inner_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(0));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_inner_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(0));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_innermost_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(0));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_innermost_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(0));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_innermost_par_node_type)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(0));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const presentation_node_type nodeTypeExp = presentation_node_type::on_click;
|
|
|
|
EXPECT_EQ(par->attlist_.presentation_node_type_.value_or(presentation_node_type::none).get_type(), nodeTypeExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_innermost_par_preset_class)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(0));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_class presetClassExp = preset_class::entrance;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_class_.value_or(preset_class::custom).get_type(), presetClassExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_innermost_par_preset_id)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(0));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_id presetIdExp = preset_id::ooo_entrance_appear;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_id_.value_or(preset_id::none).get_type(), presetIdExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_set_duration)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_set* set = GetAnimationBehaviourByIndex<anim_set>(GetInnermostPar(GetMainSequenceParByIndex(0)), 0);
|
|
ASSERT_NE(set, nullptr);
|
|
|
|
const clockvalue durationExp = clockvalue(1);
|
|
|
|
EXPECT_EQ(set->common_attlist_.smil_dur_->get_value(), durationExp.get_value());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_set_attribute_name)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_set* set = GetAnimationBehaviourByIndex<anim_set>(GetInnermostPar(GetMainSequenceParByIndex(0)), 0);
|
|
ASSERT_NE(set, nullptr);
|
|
|
|
const smil_attribute_name attributeNameExp = smil_attribute_name::visibility;
|
|
|
|
EXPECT_EQ(set->common_attlist_.smil_attribute_name_->get_type(), attributeNameExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_set_to)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_set* set = GetAnimationBehaviourByIndex<anim_set>(GetInnermostPar(GetMainSequenceParByIndex(0)), 0);
|
|
ASSERT_NE(set, nullptr);
|
|
|
|
const std::wstring toExp = L"visible";
|
|
|
|
EXPECT_EQ(set->set_attlist_.smil_to_.value_or(L"Empty"), toExp);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_outer_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(1);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"next";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.get_value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_outer_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(1);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_inner_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(1));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_inner_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(1));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_innermost_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(1));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_innermost_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(1));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_innermost_par_node_type)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(1));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const presentation_node_type nodeTypeExp = presentation_node_type::on_click;
|
|
|
|
EXPECT_EQ(par->attlist_.presentation_node_type_.value_or(presentation_node_type::none).get_type(), nodeTypeExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_innermost_par_preset_class)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(1));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_class presetClassExp = preset_class::entrance;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_class_.value_or(preset_class::custom).get_type(), presetClassExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fade_in_innermost_par_preset_id)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(1));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_id presetIdExp = preset_id::ooo_entrance_fade_in;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_id_.value_or(preset_id::none).get_type(), presetIdExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_transition_filter_duration)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_transitionFilter* transitionFilter = GetAnimationBehaviourByIndex<anim_transitionFilter>(GetInnermostPar(GetMainSequenceParByIndex(1)), 1);
|
|
ASSERT_NE(transitionFilter, nullptr);
|
|
|
|
const clockvalue durationExp = clockvalue(500);
|
|
|
|
EXPECT_EQ(transitionFilter->common_attlist_.smil_dur_.value_or(clockvalue(-1)).get_value(), durationExp.get_value());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_transition_filter_subtype)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_transitionFilter* transitionFilter = GetAnimationBehaviourByIndex<anim_transitionFilter>(GetInnermostPar(GetMainSequenceParByIndex(1)), 1);
|
|
ASSERT_NE(transitionFilter, nullptr);
|
|
|
|
const std::wstring subtypeExp = L"crossfade";
|
|
|
|
EXPECT_EQ(transitionFilter->filter_attlist_.smil_subtype_.value_or(L"Empty"), subtypeExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_transition_filter_type)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_transitionFilter* transitionFilter = GetAnimationBehaviourByIndex<anim_transitionFilter>(GetInnermostPar(GetMainSequenceParByIndex(1)), 1);
|
|
ASSERT_NE(transitionFilter, nullptr);
|
|
|
|
const smil_transition_type typeExp = smil_transition_type::fade;
|
|
|
|
EXPECT_EQ(transitionFilter->filter_attlist_.smil_type_.value().get_type(), typeExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, appear_transition_filter_mode)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_transitionFilter* transitionFilter = GetAnimationBehaviourByIndex<anim_transitionFilter>(GetInnermostPar(GetMainSequenceParByIndex(1)), 1);
|
|
ASSERT_NE(transitionFilter, nullptr);
|
|
|
|
const std::wstring modeExp = L"in";
|
|
|
|
EXPECT_EQ(transitionFilter->filter_attlist_.smil_mode_.value_or(L"Empty"), modeExp);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_outer_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(2);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"next";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.get_value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_outer_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(2);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_inner_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(2));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_inner_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(2));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_innermost_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(2));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_innermost_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(2));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_innermost_par_node_type)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(2));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const presentation_node_type nodeTypeExp = presentation_node_type::on_click;
|
|
|
|
EXPECT_EQ(par->attlist_.presentation_node_type_.value_or(presentation_node_type::none).get_type(), nodeTypeExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_innermost_par_preset_class)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(2));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_class presetClassExp = preset_class::entrance;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_class_.value_or(preset_class::custom).get_type(), presetClassExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_innermost_par_preset_id)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(2));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_id presetIdExp = preset_id::ooo_entrance_fly_in;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_id_.value_or(preset_id::none).get_type(), presetIdExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_animate_duration)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_animate* animate = GetAnimationBehaviourByIndex<anim_animate>(GetInnermostPar(GetMainSequenceParByIndex(2)), 1);
|
|
ASSERT_NE(animate, nullptr);
|
|
|
|
const clockvalue durationExp = clockvalue(500);
|
|
|
|
EXPECT_EQ(animate->common_attlist_.smil_dur_.value_or(clockvalue(-1)).get_value(), durationExp.get_value());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_animate_values)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_animate* animate = GetAnimationBehaviourByIndex<anim_animate>(GetInnermostPar(GetMainSequenceParByIndex(2)), 1);
|
|
ASSERT_NE(animate, nullptr);
|
|
|
|
const smil_values valuesExp = smil_values::parse(L"x;x");
|
|
|
|
ASSERT_EQ(animate->animate_attlist_.smil_values_->get_values().size(), valuesExp.get_values().size());
|
|
|
|
for (size_t i = 0; i < valuesExp.get_values().size(); i++)
|
|
{
|
|
EXPECT_EQ(
|
|
animate->animate_attlist_.smil_values_->get_values()[i],
|
|
valuesExp.get_values()[i]
|
|
);
|
|
}
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, fly_in_animate_key_times)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_animate* animate = GetAnimationBehaviourByIndex<anim_animate>(GetInnermostPar(GetMainSequenceParByIndex(2)), 1);
|
|
ASSERT_NE(animate, nullptr);
|
|
|
|
const smil_key_times keyTimesExp = smil_key_times::parse(L"0;1");
|
|
|
|
ASSERT_EQ(animate->animate_attlist_.smil_key_times_->get_values().size(), keyTimesExp.get_values().size());
|
|
|
|
for (size_t i = 0; i < keyTimesExp.get_values().size(); i++)
|
|
{
|
|
EXPECT_EQ(
|
|
animate->animate_attlist_.smil_key_times_->get_values()[i],
|
|
keyTimesExp.get_values()[i]
|
|
);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_outer_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(3);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"next";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.get_value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_outer_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetMainSequenceParByIndex(3);
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_inner_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(3));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_inner_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnerPar(GetMainSequenceParByIndex(3));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_innermost_par_begin)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(3));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const std::wstring beginExp = L"0s";
|
|
|
|
EXPECT_EQ(par->attlist_.smil_begin_.value_or(L"Empty"), beginExp);
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_innermost_par_fill)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(3));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const smil_fill fillExp = smil_fill::_hold;
|
|
|
|
EXPECT_EQ(par->attlist_.smil_fill_.value_or(smil_fill::none).get_type(), fillExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_innermost_par_node_type)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(3));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const presentation_node_type nodeTypeExp = presentation_node_type::on_click;
|
|
|
|
EXPECT_EQ(par->attlist_.presentation_node_type_.value_or(presentation_node_type::none).get_type(), nodeTypeExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_innermost_par_preset_class)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(3));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_class presetClassExp = preset_class::entrance;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_class_.value_or(preset_class::custom).get_type(), presetClassExp.get_type());
|
|
}
|
|
|
|
TEST_F(OOX2ODP_EntranceAnimationTest, ascend_innermost_par_preset_id)
|
|
{
|
|
using namespace cpdoccore::odf_writer;
|
|
using namespace cpdoccore::odf_types;
|
|
|
|
const anim_par* par = GetInnermostPar(GetMainSequenceParByIndex(3));
|
|
ASSERT_NE(par, nullptr);
|
|
|
|
const preset_id presetIdExp = preset_id::ooo_entrance_ascend;
|
|
|
|
EXPECT_EQ(par->par_attlist_.presentation_preset_id_.value_or(preset_id::none).get_type(), presetIdExp.get_type());
|
|
}
|