| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "precompiled_slideshow.hxx" |
| |
| #include "debug.hxx" |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| |
| #include "animationnodes/basecontainernode.hxx" |
| #include "animationnodes/paralleltimecontainer.hxx" |
| #include "animationnodes/sequentialtimecontainer.hxx" |
| #include "animationnodes/animationtransitionfilternode.hxx" |
| #include "animationnodes/animationaudionode.hxx" |
| #include "animationnodes/animationcolornode.hxx" |
| #include "animationnodes/animationcommandnode.hxx" |
| #include "animationnodes/animationpathmotionnode.hxx" |
| #include "animationnodes/animationsetnode.hxx" |
| #include "animationnodes/animationtransformnode.hxx" |
| #include "animationnodes/propertyanimationnode.hxx" |
| |
| #include <com/sun/star/animations/XAnimationNode.hpp> |
| #include <com/sun/star/animations/Event.hpp> |
| |
| #include <cstdio> |
| #include <cstdarg> |
| |
| using ::rtl::OUString; |
| using namespace ::com::sun::star; |
| |
| |
| namespace slideshow { namespace internal { |
| |
| namespace { |
| |
| class NodeContainer : public BaseContainerNode |
| { |
| public: |
| void ShowChildrenState (void) const; |
| }; |
| |
| |
| |
| |
| OUString DebugGetDescription (const AnimationNodeSharedPtr& rpNode) |
| { |
| if (::boost::dynamic_pointer_cast<BaseContainerNode>(rpNode)) |
| { |
| // Node is a container. |
| if (::boost::dynamic_pointer_cast<ParallelTimeContainer>(rpNode)) |
| return OUString::createFromAscii("ParallelTimeContainer"); |
| else if (::boost::dynamic_pointer_cast<SequentialTimeContainer>(rpNode)) |
| return OUString::createFromAscii("SequentialTimeContainer"); |
| else |
| return OUString::createFromAscii("<unknown container>"); |
| } |
| else if (::boost::dynamic_pointer_cast<AnimationTransitionFilterNode>(rpNode)) |
| return OUString::createFromAscii("AnimationTransitionFilterNode"); |
| else if (::boost::dynamic_pointer_cast<AnimationAudioNode>(rpNode)) |
| return OUString::createFromAscii("AnimationAudioNode"); |
| else if (::boost::dynamic_pointer_cast<AnimationColorNode>(rpNode)) |
| return OUString::createFromAscii("AnimationColorNode"); |
| else if (::boost::dynamic_pointer_cast<AnimationCommandNode>(rpNode)) |
| return OUString::createFromAscii("AnimationCommandNode"); |
| else if (::boost::dynamic_pointer_cast<AnimationPathMotionNode>(rpNode)) |
| return OUString::createFromAscii("AnimationPathMotionNode"); |
| else if (::boost::dynamic_pointer_cast<AnimationSetNode>(rpNode)) |
| return OUString::createFromAscii("AnimationSetNode"); |
| else if (::boost::dynamic_pointer_cast<AnimationTransformNode>(rpNode)) |
| return OUString::createFromAscii("AnimationTransformNode"); |
| else if (::boost::dynamic_pointer_cast<PropertyAnimationNode>(rpNode)) |
| return OUString::createFromAscii("PropertyAnimationNode"); |
| else |
| return OUString::createFromAscii("<unknown node type>"); |
| } |
| |
| |
| |
| |
| void DebugShowState (const AnimationNodeSharedPtr& rpNode) |
| { |
| if ( ! rpNode) |
| return; |
| |
| OUString sState; |
| OUString sStateColor; |
| switch (rpNode->getState()) |
| { |
| default: |
| case AnimationNode::INVALID: |
| sState = OUString::createFromAscii("Invalid"); |
| sStateColor = OUString::createFromAscii("firebrick1"); |
| break; |
| case AnimationNode::UNRESOLVED: |
| sState = OUString::createFromAscii("Unresolved"); |
| sStateColor = OUString::createFromAscii("dodgerblue4"); |
| break; |
| case AnimationNode::RESOLVED: |
| sState = OUString::createFromAscii("Resolved"); |
| sStateColor = OUString::createFromAscii("dodgerblue"); |
| break; |
| case AnimationNode::ACTIVE: |
| sState = OUString::createFromAscii("Active"); |
| sStateColor = OUString::createFromAscii("seagreen1"); |
| break; |
| case AnimationNode::FROZEN: |
| sState = OUString::createFromAscii("Frozen"); |
| sStateColor = OUString::createFromAscii("lightskyblue1"); |
| break; |
| case AnimationNode::ENDED: |
| sState = OUString::createFromAscii("Ended"); |
| sStateColor = OUString::createFromAscii("slategray3"); |
| break; |
| } |
| |
| const uno::Any aBegin (rpNode->getXAnimationNode()->getBegin()); |
| OUString sTrigger; |
| if (aBegin.hasValue()) |
| { |
| animations::Event aEvent; |
| double nTimeOffset; |
| const static char* sEventTriggers[] = { |
| "NONE", "ON_BEGIN", "ON_END", "BEGIN_EVENT", "END_EVENT", "ON_CLICK", |
| "ON_DBL_CLICK", "ON_MOUSE_ENTER", "ON_MOUSE_LEAVE", "ON_NEXT", "ON_PREV", |
| "ON_STOP_AUDIO", "REPEAT"}; |
| if (aBegin >>= aEvent) |
| { |
| sTrigger = OUString::createFromAscii(sEventTriggers[aEvent.Trigger]); |
| } |
| else if (aBegin >>= nTimeOffset) |
| { |
| sTrigger = OUString::valueOf(nTimeOffset); |
| } |
| else |
| { |
| sTrigger = OUString::createFromAscii("other"); |
| } |
| } |
| else |
| sTrigger = ::rtl::OUString::createFromAscii("void"); |
| |
| TRACE("Node state: n%x [label=\"%x / %x / %s\\n%s\\n%s\",style=filled,fillcolor=\"%s\"]\r", |
| rpNode.get(), |
| rpNode.get(), |
| rpNode->getXAnimationNode().get(), |
| ::rtl::OUStringToOString(sState, RTL_TEXTENCODING_ASCII_US).getStr(), |
| ::rtl::OUStringToOString(DebugGetDescription(rpNode), RTL_TEXTENCODING_ASCII_US).getStr(), |
| ::rtl::OUStringToOString(sTrigger, RTL_TEXTENCODING_ASCII_US).getStr(), |
| ::rtl::OUStringToOString(sStateColor, RTL_TEXTENCODING_ASCII_US).getStr()); |
| |
| BaseContainerNodeSharedPtr pContainer ( |
| ::boost::dynamic_pointer_cast<BaseContainerNode>(rpNode)); |
| if (pContainer) |
| ::boost::static_pointer_cast<NodeContainer>(rpNode)->ShowChildrenState(); |
| } |
| |
| |
| |
| |
| void NodeContainer::ShowChildrenState (void) const |
| { |
| for (std::size_t nIndex=0; nIndex<maChildren.size(); ++nIndex) |
| { |
| TRACE("Node connection: n%x -> n%x", this, maChildren[nIndex].get()); |
| DebugShowState(maChildren[nIndex]); |
| } |
| } |
| |
| |
| |
| |
| AnimationNodeSharedPtr DebugGetTreeRoot (const BaseNodeSharedPtr& rpNode) |
| { |
| BaseNodeSharedPtr pNode (rpNode); |
| if (pNode) |
| { |
| BaseNodeSharedPtr pParent (pNode->getParentNode()); |
| while (pParent) |
| { |
| pNode = pParent; |
| pParent = pNode->getParentNode(); |
| } |
| } |
| return pNode; |
| } |
| |
| } // end of anonymous namespace |
| |
| |
| |
| |
| void Debug_ShowNodeTree (const AnimationNodeSharedPtr& rpNode) |
| { |
| DebugTraceScope aTraceScope ("NodeTree"); |
| |
| DebugShowState(DebugGetTreeRoot(::boost::dynamic_pointer_cast<BaseNode>(rpNode))); |
| } |
| |
| |
| |
| |
| //----- Tracing --------------------------------------------------------------- |
| |
| extern "C" { |
| |
| namespace { |
| |
| class TraceData |
| { |
| public: |
| TraceData (void) |
| : mnIndentation(0), |
| mpFile(fopen(TRACE_LOG_FILE_NAME, "w")), |
| maTime() |
| { |
| } |
| |
| int mnIndentation; |
| FILE* mpFile; |
| ::canvas::tools::ElapsedTime maTime; |
| }; |
| static TraceData gTraceData; |
| |
| inline void SAL_CALL DebugTrace ( |
| const int nIndentationOffset, |
| const sal_Char* sFormat, |
| va_list args) |
| { |
| if (gTraceData.mpFile != NULL) |
| { |
| // Write line head with current time and indentation. |
| // Adapt indentation. |
| if (nIndentationOffset < 0) |
| gTraceData.mnIndentation += nIndentationOffset; |
| fprintf(gTraceData.mpFile, "%10.8f ", gTraceData.maTime.getElapsedTime()); |
| for (int nIndentation=0; nIndentation<gTraceData.mnIndentation; ++nIndentation) |
| fprintf(gTraceData.mpFile, " "); |
| if (nIndentationOffset > 0) |
| gTraceData.mnIndentation += nIndentationOffset; |
| |
| // Write message. |
| vfprintf(gTraceData.mpFile, sFormat, args); |
| fprintf(gTraceData.mpFile, "\n"); |
| fflush(gTraceData.mpFile); |
| } |
| } |
| |
| } // end of anonymous namespace |
| |
| |
| } // end of extern "C" |
| |
| void SAL_CALL DebugTraceBegin (const sal_Char* sFormat, ...) |
| { |
| va_list args; |
| va_start(args, sFormat); |
| DebugTrace(+1,sFormat, args); |
| va_end(args); |
| } |
| |
| void SAL_CALL DebugTraceEnd (const sal_Char* sFormat, ...) |
| { |
| va_list args; |
| va_start(args, sFormat); |
| DebugTrace(-1,sFormat, args); |
| va_end(args); |
| } |
| |
| void SAL_CALL DebugTraceMessage (const sal_Char* sFormat, ...) |
| { |
| va_list args; |
| va_start(args, sFormat); |
| DebugTrace(0,sFormat, args); |
| va_end(args); |
| } |
| |
| |
| |
| DebugTraceScope::DebugTraceScope (const sal_Char* sFormat, ...) |
| : msMessage(new sal_Char[mnBufferSize]) |
| { |
| va_list args; |
| va_start(args, sFormat); |
| |
| msMessage[mnBufferSize-1] = 0; |
| vsnprintf(msMessage, mnBufferSize-1, sFormat, args); |
| TRACE_BEGIN("[ %s", msMessage); |
| va_end(args); |
| } |
| |
| DebugTraceScope::~DebugTraceScope (void) |
| { |
| TRACE_END("] %s", msMessage); |
| delete [] msMessage; |
| } |
| |
| |
| } } |
| |
| #endif // OSL_DEBUG_LEVEL > 1 |
