static inline int state( CFDictionaryRef d )
{
CFStringRef s = (CFStringRef) CFDictionaryGetValue( d, CFSTR( "Player State" ) );
#define RETURN_IF_EQUAL( a, b ) \
if (CFStringCompare( a, CFSTR( #b ), 0 ) == kCFCompareEqualTo ) \
return b
// in order of frequency
RETURN_IF_EQUAL( s, Playing );
RETURN_IF_EQUAL( s, Paused );
RETURN_IF_EQUAL( s, Stopped );
return Unknown;
}
void ILayoutable::EnableCollapsed(bool val)
{
RETURN_IF_EQUAL(mIsCollapsed, val);
mIsCollapsed = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::CollapseChanged);
}
void ILayoutable::SetDirection(Direction val)
{
RETURN_IF_EQUAL(mDirection, val);
mDirection = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::ArrangeChanged);
}
void ApplicationStatics::ShowPerformance(bool val /*= true*/)
{
RETURN_IF_EQUAL(mDebugInfoFlag.IsPerformance(), val);
mDebugInfoFlag.SetOrRemoveIf(ApplicationDebugInfoFlags::Performance, val);
mUpdateWatch.Enable(val);
UpdateLabels();
}
void IButton::SetButtonState(ButtonState val)
{
RETURN_IF_EQUAL(mButtonState, val);
mButtonState = val;
OnButtonStateChanged();
}
void NodeButton::SetDisabledSelectedNode(INode* val, bool updateSize /*= false*/)
{
RETURN_IF_EQUAL(mDisabledSelectedNode, val);
DeleteChild(mDisabledSelectedNode);
mDisabledSelectedNode = val;
if (mDisabledSelectedNode!=nullptr)
{
InitNode(mDisabledSelectedNode);
mDisabledSelectedNode->SetName(MEDUSA_PREFIX(DisabledSelected));
AddChild(mDisabledSelectedNode);
mDisabledSelectedNode->SetVisible(false);
}
if (mButtonState == ButtonState::DisabledSelected)
{
OnUpdateNode();
if (updateSize&&mDisabledSelectedNode!=nullptr)
{
SetSize(mDisabledSelectedNode->Size());
}
}
}
void ILayoutable::SetMargin(const ThicknessF& val)
{
RETURN_IF_EQUAL(mMargin, val);
mMargin = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::ArrangeChanged);
}
void BoneMoveable::SetFlipX(bool val)
{
RETURN_IF_EQUAL(IsFlipX(), val);
mFlip.SetOrRemoveIf(FlipMask::X, val);
OnMoveableDirty(MoveableChangedFlags::FlipChanged);
}
void BoneMoveable::SetFlipX(bool val)
{
RETURN_IF_EQUAL(IsFlipX(), val);
MEDUSA_FLAG_ENABLE(mFlip, FlipMask::X, val);
OnMoveableDirty(MoveableChangedFlags::FlipChanged);
}
void ConnectSocketChannel::Connect()
{
RETURN_IF_EQUAL(mState, ConnectionState::Connected);
mState = ConnectionState::Connecting;
mLoop->AssertInLoopThread();
mSocket.CreateSocket();
mSocket.EnableAsync(true);
mSocket.EnableTcpNoDelay(true);
ChannelEventResult connectResult = mSocket.Connect(); //connect timeout
switch (connectResult)
{
case ChannelEventResult::Success:
mState = ConnectionState::Connected;
return;
case ChannelEventResult::InProgress:
mState = ConnectionState::Connecting;
BeginWrite();
SubmitToLoop();
break;
case ChannelEventResult::Retry:
Retry();
break;
case ChannelEventResult::Fault:
default:
OnError();
break;
}
}
void ILayoutable::SetRelativePosition(const Point2F& val)
{
RETURN_IF_EQUAL(mRelativePosition, val);
mRelativePosition = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::PositionChanged);
}
void ApplicationStatics::EnableDebugInfo(ApplicationDebugInfoFlags val)
{
RETURN_IF_EQUAL(mDebugInfoFlag, val);
mDebugInfoFlag = val;
mUpdateWatch.Enable(IsShowPerformance());
UpdateLabels();
}
void ScrollPanel::SetScrollDirection(ScrollDirection direction)
{
RETURN_IF_EQUAL(mSwipeGestureRecognizer->Direction(), direction);
mSwipeGestureRecognizer->SetDirection(direction);
mScrollModel->SetDirection(direction);
UpdateScrollStatus();
}
void ILayoutable::SetDock(DockPoint val)
{
RETURN_IF_EQUAL(mDockPoint, val);
mDockPoint = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::PositionChanged);
}
void ILayoutable::SetPadding(const Padding4F& val)
{
RETURN_IF_EQUAL(mPadding, val);
mPadding = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::ArrangeChanged);
}
void ILayoutable::SetStretchPercent(const Scale2F& val)
{
RETURN_IF_EQUAL(mStretchPercent, val);
mStretchPercent = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::SizeChanged);
}
void ILayoutable::SetStretch(Stretch val)
{
RETURN_IF_EQUAL(mStretch, val);
mStretch = val;
OnLayoutChanged(*this, NodeLayoutChangedFlags::SizeChanged);
}
void BoneMoveable::SetInheritFlag(MoveableInheritFlags val)
{
RETURN_IF_EQUAL(mInheritFlag, val);
mInheritFlag = val;
mMatrix.SetDirty();
mWorldMatrix.SetDirty();
OnMoveableDirty(MoveableChangedFlags::InheritChanged);
}
void BoneMoveable::SetSize(const Size3F& val)
{
RETURN_IF_EQUAL(mSize, val);
mSize = val;
mMatrix.SetDirty();
mWorldMatrix.SetDirty();
mWorldInverseMatrix.SetDirty();
mBoundingBox.SetDirty();
mWorldBoundingBox.SetDirty();
OnMoveableDirty(MoveableChangedFlags::SizeChanged);
}
void BoneMoveable::SetPosition(const Point3F& val)
{
RETURN_IF_EQUAL(mPosition, val);
mPosition = val;
mMatrix.SetDirty();
mWorldMatrix.SetDirty();
mBoundingBox.SetDirty();
mWorldBoundingBox.SetDirty();
OnMoveableDirty(MoveableChangedFlags::PositionChanged);
}
void TextureAtlasPage::SetPageSize(const Size2U& val)
{
RETURN_IF_EQUAL(mPageSize, val);
mPageSize = val;
//update all mesh texcoord
for (auto region : mRegions)
{
region->UpdateMesh(mPageSize);
}
}
void Camera::SetFarZ(float val)
{
RETURN_IF_EQUAL(mFarZ, val);
mFarZ = val;
if (mIsOrtho)
{
SetOrtho(mWinSize,mNearZ, mFarZ);
}
else
{
SetPerspectiveFov(mWinSize,mFovY, mNearZ, mFarZ);
}
}
void SkeletonSlot::SetAttachment(ISkeletonAttachmentModel* val)
{
RETURN_IF_EQUAL(mAttachment, val);
mAttachment = val;
if (mAttachment != nullptr)
{
SetRenderingObject(mAttachment->GetRenderingObject());
}
else
{
SetRenderingObject(nullptr);
}
}
void BaseSirenCustomType::SetParentType(BaseSirenCustomType* val)
{
RETURN_IF_EQUAL(mParentType, val);
mParentType = val;
if (mParentType != nullptr)
{
mFullName = mParentType->FullName() + "." + mName;
}
else
{
mFullName = mName;
}
}
void SingleLineFontModel::SetText( WStringRef text )
{
RETURN_IF_EQUAL(mText,text);
mText=text;
RemoveAllMeshes();
ResetCachedMeshes();
RETURN_IF_EMPTY(mText);
Size2F outSize;
List<BaseFontMesh*> meshes;
List<IMaterial*> outMaterials;
TextLayouter::LayoutSingleLineText(meshes, outMaterials,outSize,*mFont,mText,mAlignment,mRestrictSize);
//AddMeshes(meshes);
SetSize(outSize);
}
void BaseMultipleBatchRenderQueue::Update(RenderableChangedFlags changedFlag)
{
RETURN_IF_EQUAL(changedFlag, RenderableChangedFlags::None);
if (mIsNeedToSort)
{
Linq::InsertSortByOtherCompare<IRenderable*, EqualCompare,IRenderableCompareByRenderingPriority>(mNodes);
mIsNeedToSort = false;
}
if (MEDUSA_FLAG_HAS(changedFlag,RenderableChangedFlags::BatchChanged))
{
OnUpdateBatchList();
OnUpdateRenderGroup();
mIsCommandChanged = true;
}
mIsCommandChanged |= OnUpdateBatchData();
}
void BaseSingleBatchRenderQueue::Update(RenderableChangedFlags changedFlag)
{
RETURN_IF_EQUAL(changedFlag, RenderableChangedFlags::None);
if (changedFlag.IsBatchChanged()||changedFlag.IsRenderQueueChanged())
{
mBatch->Prepare();
if (!mNodes.IsEmpty())
{
IRenderable* node = mNodes.First();
mBatch->SetEffect(node->Material()->Effect());
mBatch->SetMaterial(node->Material());
mBatch->SetDrawMode(node->Material()->DrawMode());
mBatch->SetStateTreeNode(node->RenderStateTreeNode());
}
FOR_EACH_COLLECTION(i, mNodes)
{
mBatch->AddNode(*i);
}
void IProgressBar::SetProgressType(ProgressType val)
{
RETURN_IF_EQUAL(mProgressType,val);
mProgressType = val;
OnUpdateMesh(true);
}
void IScrollMathModel::SetDirection(ScrollDirection val)
{
RETURN_IF_EQUAL(mDirection, val);
mDirection = val;
OnUpdate();
}
void ILayoutable::EnableLayout(bool val)
{
RETURN_IF_EQUAL(mLayoutEnabled,val);
mLayoutEnabled = val;
}
