예제 #1
0
        protected virtual BlockCCControlData ParsePropTypeBlockCcControl(CCNode node, CCNode parent, CCBReader reader)
        {
            string selectorName = reader.ReadCachedString();
            var selectorTarget = (CCBTargetType) reader.ReadInt(false);
            var controlEvents = (CCControlEvent) reader.ReadInt(false);

            if (selectorTarget != CCBTargetType.None)
            {
                if (!reader.IsJSControlled())
                {
                    object target = null;
                    if (selectorTarget == CCBTargetType.DocumentRoot)
                    {
                        target = reader.AnimationManager.RootNode;
                    }
                    else if (selectorTarget == CCBTargetType.Owner)
                    {
                        target = reader.Owner;
                    }

                    if (target != null)
                    {
                        if (selectorName.Length > 0)
                        {
                            Action<object, CCControlEvent> selCCControlHandler = null;

                            var targetAsCCBSelectorResolver = target as ICCBSelectorResolver;
                            if (targetAsCCBSelectorResolver != null)
                            {
                                selCCControlHandler = targetAsCCBSelectorResolver.OnResolveCCBCCControlSelector(target,
                                                                                                                selectorName);
                            }
                            if (selCCControlHandler == null)
                            {
                                ICCBSelectorResolver ccbSelectorResolver = reader.SelectorResolver;
                                if (ccbSelectorResolver != null)
                                {
                                    selCCControlHandler = ccbSelectorResolver.OnResolveCCBCCControlSelector(target,
                                                                                                            selectorName);
                                }
                            }

                            if (selCCControlHandler == null)
                            {
                                CCLog.Log("Skipping selector '{0}' since no CCBSelectorResolver is present.",
                                          selectorName);
                            }
                            else
                            {
                                var blockCCControlData = new BlockCCControlData();
                                blockCCControlData.mSELCCControlHandler = selCCControlHandler;

                                blockCCControlData.mTarget = target;
                                blockCCControlData.mControlEvents = controlEvents;

                                return blockCCControlData;
                            }
                        }
                        else
                        {
                            CCLog.Log("Unexpected empty selector.");
                        }
                    }
                    else
                    {
                        CCLog.Log("Unexpected NULL target for selector.");
                    }
                }
                else
                {
                    if (selectorTarget == CCBTargetType.DocumentRoot)
                    {
                        reader.AddDocumentCallbackNode(node);
                        reader.AddDocumentCallbackName(selectorName);

                    }
                    else
                    {
                        reader.AddOwnerCallbackNode(node);
                        reader.AddOwnerCallbackName(selectorName);
                    }
                }
            }

            return null;
        }
예제 #2
0
 protected virtual void OnHandlePropTypeBlockCcControl(CCNode node, CCNode parent, string propertyName,
                                                       BlockCCControlData blockControlData, CCBReader reader)
 {
     CCLog.Log("Unexpected property type: '{0}'!", propertyName);
     Debug.Assert(false);
 }
예제 #3
0
        public virtual void ParseProperties(CCNode node, CCNode parent, CCBReader reader)
        {
            int numRegularProps = reader.ReadInt(false);
            int numExturaProps  = reader.ReadInt(false);
            int propertyCount   = numRegularProps + numExturaProps;

            for (int i = 0; i < propertyCount; i++)
            {
                bool   isExtraProp  = (i >= numRegularProps);
                int    type         = reader.ReadInt(false);
                string propertyName = reader.ReadCachedString();

                // Check if the property can be set for this platform
                bool setProp = false;

                var platform = (CCBPlatform)reader.ReadByte();
                if (platform == CCBPlatform.All)
                {
                    setProp = true;
                }
#if __CC_PLATFORM_IOS
                if (platform == kCCBPlatform.kCCBPlatformIOS)
                {
                    setProp = true;
                }
#elif __CC_PLATFORM_MAC
                if (platform == kCCBPlatform.kCCBPlatformMac)
                {
                    setProp = true;
                }
#endif

                // Forward properties for sub ccb files
                if (node is CCBFile)
                {
                    var ccbNode = (CCBFile)node;
                    if (ccbNode.FileNode != null && isExtraProp)
                    {
                        node = ccbNode.FileNode;

                        // Skip properties that doesn't have a value to override
                        var extraPropsNames = (List <string>)node.UserObject;
                        setProp &= extraPropsNames.Contains(propertyName);
                    }
                }
                else if (isExtraProp && node == reader.AnimationManager.RootNode)
                {
                    var extraPropsNames = (List <string>)node.UserObject;
                    if (extraPropsNames == null)
                    {
                        extraPropsNames = new List <string>();
                        node.UserObject = extraPropsNames;
                    }

                    extraPropsNames.Add(propertyName);
                }

                switch ((CCBPropType)type)
                {
                case CCBPropType.Position:
                {
                    CCPoint position = ParsePropTypePosition(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypePosition(node, parent, propertyName, position, reader);
                    }
                    break;
                }

                case CCBPropType.Point:
                {
                    CCPoint point = ParsePropTypePoint(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypePoint(node, parent, propertyName, point, reader);
                    }
                    break;
                }

                case CCBPropType.PointLock:
                {
                    CCPoint pointLock = ParsePropTypePointLock(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypePointLock(node, parent, propertyName, pointLock, reader);
                    }
                    break;
                }

                case CCBPropType.Size:
                {
                    CCSize size = ParsePropTypeSize(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeSize(node, parent, propertyName, size, reader);
                    }
                    break;
                }

                case CCBPropType.ScaleLock:
                {
                    float[] scaleLock = ParsePropTypeScaleLock(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeScaleLock(node, parent, propertyName, scaleLock, reader);
                    }
                    break;
                }

                case CCBPropType.Float:
                {
                    float f = ParsePropTypeFloat(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFloat(node, parent, propertyName, f, reader);
                    }
                    break;
                }

                case CCBPropType.Degrees:
                {
                    float degrees = ParsePropTypeDegrees(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeDegrees(node, parent, propertyName, degrees, reader);
                    }
                    break;
                }

                case CCBPropType.FloatScale:
                {
                    float floatScale = ParsePropTypeFloatScale(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFloatScale(node, parent, propertyName, floatScale, reader);
                    }
                    break;
                }

                case CCBPropType.Integer:
                {
                    int integer = ParsePropTypeInteger(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeInteger(node, parent, propertyName, integer, reader);
                    }
                    break;
                }

                case CCBPropType.IntegerLabeled:
                {
                    int integerLabeled = ParsePropTypeIntegerLabeled(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeIntegerLabeled(node, parent, propertyName, integerLabeled, reader);
                    }
                    break;
                }

                case CCBPropType.FloatVar:
                {
                    float[] floatVar = ParsePropTypeFloatVar(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFloatVar(node, parent, propertyName, floatVar, reader);
                    }
                    break;
                }

                case CCBPropType.Check:
                {
                    bool check = ParsePropTypeCheck(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeCheck(node, parent, propertyName, check, reader);
                    }
                    break;
                }

                case CCBPropType.SpriteFrame:
                {
                    CCSpriteFrame ccSpriteFrame = ParsePropTypeSpriteFrame(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeSpriteFrame(node, parent, propertyName, ccSpriteFrame, reader);
                    }
                    break;
                }

                case CCBPropType.Animation:
                {
                    CCAnimation ccAnimation = ParsePropTypeAnimation(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeAnimation(node, parent, propertyName, ccAnimation, reader);
                    }
                    break;
                }

                case CCBPropType.Texture:
                {
                    CCTexture2D ccTexture2D = ParsePropTypeTexture(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeTexture(node, parent, propertyName, ccTexture2D, reader);
                    }
                    break;
                }

                case CCBPropType.Byte:
                {
                    byte b = ParsePropTypeByte(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeByte(node, parent, propertyName, b, reader);
                    }
                    break;
                }

                case CCBPropType.Color3:
                {
                    CCColor3B color3B = ParsePropTypeColor3(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeColor3(node, parent, propertyName, color3B, reader);
                    }
                    break;
                }

                case CCBPropType.Color4FVar:
                {
                    CCColor4F[] color4FVar = ParsePropTypeColor4FVar(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeColor4FVar(node, parent, propertyName, color4FVar, reader);
                    }
                    break;
                }

                case CCBPropType.Flip:
                {
                    bool[] flip = ParsePropTypeFlip(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFlip(node, parent, propertyName, flip, reader);
                    }
                    break;
                }

                case CCBPropType.Blendmode:
                {
                    CCBlendFunc blendFunc = ParsePropTypeBlendFunc(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeBlendFunc(node, parent, propertyName, blendFunc, reader);
                    }
                    break;
                }

                case CCBPropType.FntFile:
                {
                    string fntFile = ParsePropTypeFntFile(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFntFile(node, parent, propertyName, fntFile, reader);
                    }
                    break;
                }

                case CCBPropType.FontTTF:
                {
                    string fontTTF = ParsePropTypeFontTTF(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFontTTF(node, parent, propertyName, fontTTF, reader);
                    }
                    break;
                }

                case CCBPropType.String:
                {
                    string s = ParsePropTypeString(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeString(node, parent, propertyName, s, reader);
                    }
                    break;
                }

                case CCBPropType.Text:
                {
                    string text = ParsePropTypeText(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeText(node, parent, propertyName, text, reader);
                    }
                    break;
                }

                case CCBPropType.Block:
                {
                    BlockData blockData = ParsePropTypeBlock(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeBlock(node, parent, propertyName, blockData, reader);
                    }
                    break;
                }

                case CCBPropType.BlockCCControl:
                {
                    BlockCCControlData blockCCControlData = ParsePropTypeBlockCcControl(node, parent, reader);
                    if (setProp && blockCCControlData != null)
                    {
                        OnHandlePropTypeBlockCcControl(node, parent, propertyName, blockCCControlData, reader);
                    }
                    break;
                }

                case CCBPropType.CCBFile:
                {
                    CCNode ccbFileNode = ParsePropTypeCcbFile(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeCCBFile(node, parent, propertyName, ccbFileNode, reader);
                    }
                    break;
                }

                default:
                    //ASSERT_FAIL_UNEXPECTED_PROPERTYTYPE(type);
                    break;
                }
            }
        }
예제 #4
0
        protected virtual BlockCCControlData ParsePropTypeBlockCcControl(CCNode node, CCNode parent, CCBReader reader)
        {
            string selectorName   = reader.ReadCachedString();
            var    selectorTarget = (CCBTargetType)reader.ReadInt(false);
            var    controlEvents  = (CCControlEvent)reader.ReadInt(false);

            if (selectorTarget != CCBTargetType.None)
            {
                object target = null;
                if (selectorTarget == CCBTargetType.DocumentRoot)
                {
                    target = reader.AnimationManager.RootNode;
                }
                else if (selectorTarget == CCBTargetType.Owner)
                {
                    target = reader.Owner;
                }

                if (target != null)
                {
                    if (selectorName.Length > 0)
                    {
                        Action <object, CCControlEvent> selCCControlHandler = null;

                        var targetAsCCBSelectorResolver = target as ICCBSelectorResolver;
                        if (targetAsCCBSelectorResolver != null)
                        {
                            selCCControlHandler = targetAsCCBSelectorResolver.OnResolveCCBCCControlSelector(target, selectorName);
                        }
                        if (selCCControlHandler == null)
                        {
                            ICCBSelectorResolver ccbSelectorResolver = reader.SelectorResolver;
                            if (ccbSelectorResolver != null)
                            {
                                selCCControlHandler = ccbSelectorResolver.OnResolveCCBCCControlSelector(target, selectorName);
                            }
                        }

                        if (selCCControlHandler == null)
                        {
                            CCLog.Log("Skipping selector '{0}' since no CCBSelectorResolver is present.", selectorName);
                        }
                        else
                        {
                            var blockCCControlData = new BlockCCControlData();
                            blockCCControlData.mSELCCControlHandler = selCCControlHandler;

                            blockCCControlData.mTarget        = target;
                            blockCCControlData.mControlEvents = controlEvents;

                            return(blockCCControlData);
                        }
                    }
                    else
                    {
                        CCLog.Log("Unexpected empty selector.");
                    }
                }
                else
                {
                    CCLog.Log("Unexpected NULL target for selector.");
                }
            }

            return(null);
        }
예제 #5
0
 protected virtual void OnHandlePropTypeBlockCcControl(CCNode node, CCNode parent, string propertyName,
                                                       BlockCCControlData blockControlData, CCBReader reader)
 {
     CCLog.Log("Unexpected property type: '{0}'!", propertyName);
     Debug.Assert(false);
 }