morphing_ins.c.svn-base

A Flash Player with ActionScript support. Write in C and C++. It have two part, one is Player and an

            EndCurvedRecord= (struct CurvedEdgeRecord*)malloc(sizeof(struct CurvedEdgeRecord));
            assert(EndCurvedRecord!= NULL);
            bzero((void *)(EndCurvedRecord),sizeof(struct CurvedEdgeRecord));
            EndStraightRecord = (struct StraightEdgeRecord*)EndRed;
            if(StartRed->Flags&64) {
                data_p->isStraight = 0;
                StraightToCurved(EndStraightRecord,EndCurvedRecord);
            } else {
                StartCurvedRecord = (struct CurvedEdgeRecord*)StartRed;
                VerifyStraight(node_p,EndStraightRecord,StartCurvedRecord,EndCurvedRecord);
            }
        } else {
            //curved record
            EndCurvedRecord = (struct CurvedEdgeRecord*)EndRed;
        }
        //do morph
        if(data_p->isStraight == 1) {
            outStraightRecord = (struct StraightEdgeRecord*)malloc(sizeof(struct StraightEdgeRecord));
            assert(outStraightRecord != NULL);
            bzero((void *)(outStraightRecord),sizeof(struct StraightEdgeRecord));
            StraightToStraight(node_p,StartStraightRecord,EndStraightRecord,outStraightRecord);

            tmpCurRed = (struct ShapeRecord*)outStraightRecord;
            tmpCurRed->Flags = StartRed->Flags;

        } else {
            outCurvedRecord = (struct CurvedEdgeRecord*)malloc(sizeof(struct CurvedEdgeRecord));
            assert(outCurvedRecord != NULL);
            bzero((void *)(outCurvedRecord),sizeof(struct CurvedEdgeRecord));
            CurvedToCurved(node_p,StartCurvedRecord,EndCurvedRecord,outCurvedRecord);

            tmpCurRed = (struct ShapeRecord*)outCurvedRecord;
            tmpCurRed->Flags = StartRed->Flags&191;
        }
    } else {
        StartSChangeRecord = (struct StyleChangeRecord*)StartRed;
        EndSChangeRecord = (struct StyleChangeRecord*)EndRed;
        outSChangeRecord = (struct StyleChangeRecord*)malloc(sizeof(struct StyleChangeRecord));
        assert(outSChangeRecord != NULL);
        bzero((void *)(outSChangeRecord),sizeof(struct StyleChangeRecord));
        if(StartRed->Flags&1) {
            //start & end point morph
            StartToCurrent(node_p,StartSChangeRecord,EndSChangeRecord,outSChangeRecord);
        }
        outSChangeRecord->FillStyle0 = StartSChangeRecord->FillStyle0;
        outSChangeRecord->FillStyle1 = StartSChangeRecord->FillStyle1;
        outSChangeRecord->LineStyle = StartSChangeRecord->LineStyle;
        outSChangeRecord->FillStylesP = StartSChangeRecord->FillStylesP;
        outSChangeRecord->LineStylesP = StartSChangeRecord->LineStylesP;
        outSChangeRecord->NumFillBits = StartSChangeRecord->NumFillBits;
        outSChangeRecord->NumLineBits = StartSChangeRecord->NumLineBits;

        tmpCurRed = (struct ShapeRecord*)outSChangeRecord;
        tmpCurRed->Flags = StartRed->Flags;
    }

    *outCurRed = tmpCurRed;
    /*
    	if(StartRed->Flags&64)
    		if(StartCurvedRecord)
    			free(StartCurvedRecord );
    	if(EndRed->Flags&64)
    		if(EndCurvedRecord)
    			free(EndCurvedRecord );
    */
#ifdef PRINT_DG

    printf("flash: loading GetShapePos End---\n");
#endif

    return 0;
}
int freeShape(GNode* node_p) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);

    struct ShapeRecord *tempShape;
    free(data_p->GlobalShape.FillStylesP);
    data_p->GlobalShape.FillStylesP = NULL;
    free(data_p->GlobalShape.LineStylesP);
    data_p->GlobalShape.LineStylesP = NULL;
    tempShape = NULL;
    if(data_p->GlobalShape.ShapeRecordsP)
        while(data_p->GlobalShape.ShapeRecordsP) {
            tempShape =data_p->GlobalShape.ShapeRecordsP->NextP;
            free(data_p->GlobalShape.ShapeRecordsP);
            data_p->GlobalShape.ShapeRecordsP = tempShape;
        }
    /*
    	if(&data_p->GlobalShape)
    		freeDefineShape(&data_p->GlobalShape);
    */
    return 0;
}
int mallocShape(GNode* node_p) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);

    data_p->GlobalShape.FillStylesP = (struct FillStyleArray*)malloc(sizeof(struct FillStyleArray));
    assert(data_p->GlobalShape.FillStylesP != NULL);
    bzero((void *)(data_p->GlobalShape.FillStylesP),sizeof(struct FillStyleArray));
    data_p->GlobalShape.LineStylesP = (struct LineStyleArray*)malloc(sizeof(struct LineStyleArray));
    assert(data_p->GlobalShape.LineStylesP != NULL);
    bzero((void *)(data_p->GlobalShape.LineStylesP),sizeof(struct LineStyleArray));
    data_p->GlobalShape.ShapeRecordsP = (struct ShapeRecord*)malloc(sizeof(struct ShapeRecord));
    assert(data_p->GlobalShape.ShapeRecordsP != NULL);
    bzero((void *)(data_p->GlobalShape.ShapeRecordsP),sizeof(struct ShapeRecord));
    return 0;
}
//add Flags
int AddFlags(struct  DefineMorphShape *Morph,struct ShapeRecord *FlagRed) {
    struct StyleChangeRecord	*SChangeRecord;
    struct StyleChangeRecord	*CurFlag;

    SChangeRecord = (struct StyleChangeRecord*)Morph->StartEdgesP;
    CurFlag = (struct StyleChangeRecord*)FlagRed;
    SChangeRecord->Flags = SChangeRecord->Flags|CurFlag->Flags;
    //SChangeRecord->Flags = CurFlag->Flags;
    SChangeRecord->MoveDeltaX = CurFlag->MoveDeltaX ;
    SChangeRecord->MoveDeltaY = CurFlag->MoveDeltaY ;
    SChangeRecord->LineStyle = CurFlag->LineStyle ;
    SChangeRecord->FillStylesP = CurFlag->FillStylesP;
    SChangeRecord->LineStylesP = CurFlag->LineStylesP;
    SChangeRecord->NumLineBits= CurFlag->NumLineBits;

    return 0;
}
//delete multy edges for out shape to solid fill
int DelEdges(GNode* node_p,struct  DefineMorphShape *Morph,struct ShapeRecord *FlagRed) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);
    struct StyleChangeRecord	*SChangeRecord;
    struct StyleChangeRecord	*CurFlag;
    struct StyleChangeRecord	*CurEndFlag;
    struct ShapeRecord	*tmpRecord;

    if(Morph->StartEdgesP->Flags&1)
        return 0;

    if(Morph->StartEdgesP->Flags&6) {
        SChangeRecord = (struct StyleChangeRecord*)Morph->StartEdgesP;
        CurFlag = (struct StyleChangeRecord*)FlagRed;
        CurFlag->Flags = SChangeRecord->Flags|(CurFlag->Flags&9);
        CurFlag->FillStyle0 = SChangeRecord->FillStyle0;
        CurFlag->FillStyle1 = SChangeRecord->FillStyle1;
        CurFlag->NumFillBits = SChangeRecord->NumFillBits;
    }
    Morph->StartEdgesP = Morph->StartEdgesP->NextP ;
    if(Morph->EndEdgesP->Flags&1) {
        Morph->EndEdgesP = Morph->EndEdgesP->NextP ;
    }

    while(Morph->StartEdgesP) {
        if(Morph->StartEdgesP->Flags&1) {

            if(Morph->EndEdgesP->Flags&1) {
                break;
            } else {
                tmpRecord = Morph->EndEdgesP;
                CurEndFlag =(struct StyleChangeRecord*)malloc(sizeof(struct StyleChangeRecord));
                bzero((void *)(CurEndFlag),sizeof(struct StyleChangeRecord));
                CurEndFlag->Flags = 1;

                CurEndFlag->MoveDeltaX = data_p->EndFlagP.MoveDeltaX;
                CurEndFlag->MoveDeltaY = data_p->EndFlagP.MoveDeltaY;

                CurEndFlag->NextP = tmpRecord;
                Morph->EndEdgesP = (struct ShapeRecord*)CurEndFlag;

                break;
            }
        }
        if(Morph->StartEdgesP->Flags&6) {
            if(Morph->EndEdgesP->Flags&1) {
                //				CurEndFlag = (struct StyleChangeRecord *)Morph->EndEdgesP;
                //				FlagRed = Morph->StartEdgesP;
                AddFlags(Morph,FlagRed);
                break;
            }
            //				Morph->EndEdgesP = Morph->EndEdgesP->NextP ;
            Morph->StartEdgesP = Morph->StartEdgesP->NextP ;
        } else {
            if(Morph->EndEdgesP->Flags&1) {
                CurEndFlag = (struct StyleChangeRecord *)Morph->EndEdgesP;
                Morph->EndEdgesP = Morph->EndEdgesP->NextP ;
            } else {
                Morph->StartEdgesP = Morph->StartEdgesP->NextP ;
                Morph->EndEdgesP = Morph->EndEdgesP->NextP ;
            }
        }
    }
    return 0;
}
int AddFrame(struct  DefineMorphShape *Morph) {
    struct StyleChangeRecord	*StrRecord;
    struct StyleChangeRecord	*EndRecord;
    struct ShapeRecord	*tmpRecord;

    StrRecord = (struct StyleChangeRecord*)Morph->StartEdgesP;
    StrRecord->Flags = StrRecord->Flags|1;
    StrRecord->MoveDeltaX = 0;
    StrRecord->MoveDeltaY = 0;

    tmpRecord = Morph->EndEdgesP;
    if(tmpRecord->Flags&1) {
        return 0;
    }

    EndRecord = (struct StyleChangeRecord*)malloc(sizeof(struct StyleChangeRecord));
    bzero((void *)(EndRecord),sizeof(struct StyleChangeRecord));
    EndRecord->Flags = 1;
    EndRecord->MoveDeltaX = 0;
    EndRecord->MoveDeltaY = 0;
    EndRecord->FillStyle0 = 0;
    EndRecord->FillStyle1 = 0;
    EndRecord->LineStyle = 0;
    EndRecord->FillStylesP = NULL;
    EndRecord->LineStylesP = NULL;
    EndRecord->NumLineBits = 0;
    EndRecord->NumFillBits = 0;

    EndRecord->NextP = tmpRecord;
    Morph->EndEdgesP = (struct ShapeRecord*)EndRecord;

    return 0;
}

int setStyleChangeRecord(struct StyleChangeRecord *red,struct ShapeRecord *ShapeP) {
    struct StyleChangeRecord *tmpRed;

    tmpRed = (struct StyleChangeRecord*)ShapeP;

    red->Flags = tmpRed->Flags;
    red->MoveDeltaX = tmpRed->MoveDeltaX;
    red->MoveDeltaY = tmpRed->MoveDeltaY;
    red->FillStyle0 = tmpRed->FillStyle0;
    red->FillStyle1 = tmpRed->FillStyle1;
    red->LineStyle = tmpRed->LineStyle;
    red->FillStylesP = tmpRed->FillStylesP;
    red->LineStylesP = tmpRed->LineStylesP;
    red->NumLineBits = tmpRed->NumLineBits;
    red->NumFillBits = tmpRed->NumFillBits;

    return 0;
}
//the func MorphShape change to Shape
void mrp_ins_update_shape(GNode* node_p) {
    mrp_ins_t	 		*data_p = 	(mrp_ins_t*)(node_p->data);
    struct DefineMorphShape 	*inMorphShape = (struct DefineMorphShape*)(data_p->define_p);
    //	struct DefineShape	*outShape =

    struct ShapeRecord *headShapeP;
    struct ShapeRecord *SShapeP,*RShapeP;
    struct  DefineMorphShape tmpMorphShape;

    struct ShapeRecord *FlagP;

#ifdef PRINT_LOG

    printf("flash: loading MorphShapeToShap Start---\n");
#endif

    //    if (data_p->last_ratio == data_p->ratio)
    //        return;

    freeShape(node_p);
    mallocShape(node_p);
    tmpMorphShape = *inMorphShape;
    //deal with RECT
    CurrBounds(node_p,tmpMorphShape.StartBounds,tmpMorphShape.EndBounds,&data_p->GlobalShape.ShapeBounds);
    //deal with ShapeRecord
    //	data_p->EndFlagP.MoveDeltaX = 0;
    //	data_p->EndFlagP.MoveDeltaY = 0;
    if(!(tmpMorphShape.StartEdgesP->Flags&1)) {
        AddFrame(&tmpMorphShape);
    }
    headShapeP = NULL;
    RShapeP = NULL;
    while(tmpMorphShape.StartEdgesP) {
        if(tmpMorphShape.StartEdgesP->Flags&6) {
            DelEdges(node_p,&tmpMorphShape,FlagP);
            //			AddFlags(&tmpMorphShape,FlagP);
            if(tmpMorphShape.StartEdgesP==NULL)
                break;
        }
        SShapeP = (struct ShapeRecord*)malloc(sizeof(struct ShapeRecord));
        assert(SShapeP != NULL);
        bzero((void *)(SShapeP),sizeof(struct ShapeRecord));
        GetShapePos(node_p,tmpMorphShape.StartEdgesP,tmpMorphShape.EndEdgesP,&SShapeP);
        //		SShapeP->Flags = tmpMorphShape.StartEdgesP->Flags ;
        if(headShapeP==NULL)
            headShapeP = SShapeP;
        else
            RShapeP->NextP = SShapeP;

        RShapeP = SShapeP;
        if(tmpMorphShape.StartEdgesP->Flags&128) {
            tmpMorphShape.StartEdgesP = tmpMorphShape.StartEdgesP->NextP;
            tmpMorphShape.EndEdgesP = tmpMorphShape.EndEdgesP->NextP;
        } else {
            if(tmpMorphShape.StartEdgesP->Flags&1) {
                FlagP = SShapeP;
                tmpMorphShape.StartEdgesP = tmpMorphShape.StartEdgesP->NextP;
                if(tmpMorphShape.EndEdgesP->Flags&1) {
                    setStyleChangeRecord(&data_p->EndFlagP,tmpMorphShape.EndEdgesP) ;
                    tmpMorphShape.EndEdgesP = tmpMorphShape.EndEdgesP->NextP;
                }
            } else {
                tmpMorphShape.StartEdgesP = tmpMorphShape.StartEdgesP->NextP;
                if(tmpMorphShape.EndEdgesP->Flags&1) {
                    tmpMorphShape.EndEdgesP = tmpMorphShape.EndEdgesP->NextP;
                }

            }
        }
    }
    if(RShapeP!=NULL)
        RShapeP->NextP = NULL;
    data_p->GlobalShape.ShapeRecordsP = headShapeP;

    //deal with MorphFillStyleArray
    CurrFillArray(node_p,tmpMorphShape.MorphFillStylesP,&data_p->GlobalShape.FillStylesP);
    //deal with MorphLineStyleArray
    CurrLineArray(node_p,tmpMorphShape.MorphLineStylesP,&data_p->GlobalShape.LineStylesP);
    data_p->GlobalShape.CharacterType = CharShape;
    data_p->shape_p = &data_p->GlobalShape;

    //    data_p->last_ratio = data_p->ratio;
#ifdef PRINT_LOG

    printf("flash: loading MorphShapeToShap End---\n");
    printf("--------flash: loading MorphShapeToShap data_p->ratio--------------%u \n",data_p->ratio);
    if(Ratio == 0)
        printf("--------flash: loading MorphShapeToShap data_p->ratio--------------\n");
#endif

}

void mrp_ins_change(GNode* node_p,struct PlaceObject *cmd_p) {
    mrp_ins_t    *data_p   = (mrp_ins_t*)(node_p->data);
    if (cmd_p->Flags & PlaceFlagHasRatio) {
        data_p->ratio = cmd_p->Ratio;
    };
    if (data_p->last_ratio != data_p->ratio) {
        mrp_ins_update_shape(node_p);
        data_p->pic_dirty = TRUE;
    };
    data_p->last_ratio = data_p->ratio;
};