scharacterparser.java

j2me 上面flash播放器。非常值得研究。就是版本只到2.0

                point1.y -= byte3;
                point3.y -= byte3;
            }
            break;

        case 3: // '\003'
            if(flag)
            {
                int k = i >= 0 ? ((int) (i <= 0 ? 0 : 1)) : -1;
                point.x += k;
                point2.x += k;
                k *= 2;
                point1.x -= k;
                point3.x -= k;
            } else
            {
                int l = j >= 0 ? ((int) (j <= 0 ? 0 : 1)) : -1;
                point.y += l;
                point2.y += l;
                l *= 2;
                point1.y -= l;
                point3.y -= l;
            }
            break;
        }
        AddEdge(point2, point);
        AddEdge(point1, point3);
        if(!strokeInited)
        {
            lStartPt.x = point.x;
            lStartPt.y = point.y;
            startOrigin.x = curve.anchor1x;
            startOrigin.y = curve.anchor1y;
            rStartPt.x = point1.x;
            rStartPt.y = point1.y;
            strokeInited = true;
        } else
        {
            AddEdge(point, lCurPt);
            AddEdge(rCurPt, point1);
        }
        lCurPt.x = point2.x;
        lCurPt.y = point2.y;
        curOrigin.x = curve.anchor2x;
        curOrigin.y = curve.anchor2y;
        rCurPt.x = point3.x;
        rCurPt.y = point3.y;
    }

/*    private static final void curveOffsetX(Curve curve, int i)
    {
        curve.anchor1x += i;
        curve.controlx += i;
        curve.anchor2x += i;
    }

    private static final void curveOffsetY(Curve curve, int i)
    {
        curve.anchor1y += i;
        curve.controly += i;
        curve.anchor2y += i;
    }

    private static final boolean sameSign(int i, int j)
    {
        if(i == 0)
            return true;
        if(i > 0)
            return j >= 0;
        return j <= 0;
    }*/

    final void StrokeThinCurve(Curve curve)
    {
        if(!curve.isLine && curve.flatness() > 2)
        {
            int i = curve.controly - curve.anchor1y;
            int k = curve.anchor1x - curve.controlx;
            int i1 = curve.anchor2y - curve.controly;
            int j1 = curve.controlx - curve.anchor2x;
            boolean flag = (i <= 0 ? -i : i) > (k <= 0 ? -k : k);
            boolean flag2 = (i1 <= 0 ? -i1 : i1) > (j1 <= 0 ? -j1 : j1);
            if(flag != flag2 || (i != 0 ? i <= 0 ? i1 > 0 && true : i1 < 0 && true : false) || (k != 0 ? k <= 0 ? j1 > 0 && true : j1 < 0 && true : false))
            {
                Curve curve3 = new Curve(curve);
                Curve curve4 = curve3.divide(32768);
                StrokeThinCurve(curve3);
                StrokeThinCurve(curve4);
                return;
            }
        }
        int j = curve.anchor2y - curve.anchor1y;
        int l = curve.anchor1x - curve.anchor2x;
        Curve curve1 = new Curve(curve);
        Curve curve2 = new Curve(curve);
        boolean flag1 = (j <= 0 ? -j : j) > (l <= 0 ? -l : l);
        switch(lineThickness)
        {
        default:
            break;

        case 1: // '\001'
            if(flag1)
            {
                byte byte0 = j >= 0 ? ((byte) (((byte)(j <= 0 ? 0 : 1)))) : -1;
                if(byte0 > 0)
                {
                    curve1.anchor1x += byte0;
                    curve1.controlx += byte0;
                    curve1.anchor2x += byte0;
                } else
                {
                    int k1 = -byte0;
                    curve2.anchor1x += k1;
                    curve2.controlx += k1;
                    curve2.anchor2x += k1;
                }
                break;
            }
            byte byte1 = l >= 0 ? ((byte) (((byte)(l <= 0 ? 0 : 1)))) : -1;
            if(byte1 > 0)
            {
                curve1.anchor1y += byte1;
                curve1.controly += byte1;
                curve1.anchor2y += byte1;
            } else
            {
                int l1 = -byte1;
                curve2.anchor1y += l1;
                curve2.controly += l1;
                curve2.anchor2y += l1;
            }
            break;

        case 2: // '\002'
            if(flag1)
            {
                byte byte2 = j >= 0 ? ((byte) (((byte)(j <= 0 ? 0 : 1)))) : -1;
                curve1.anchor1x += byte2;
                curve1.controlx += byte2;
                curve1.anchor2x += byte2;
                int i2 = -byte2;
                curve2.anchor1x += i2;
                curve2.controlx += i2;
                curve2.anchor2x += i2;
            } else
            {
                byte byte3 = l >= 0 ? ((byte) (((byte)(l <= 0 ? 0 : 1)))) : -1;
                curve1.anchor1y += byte3;
                curve1.controly += byte3;
                curve1.anchor2y += byte3;
                int j2 = -byte3;
                curve2.anchor1y += j2;
                curve2.controly += j2;
                curve2.anchor2y += j2;
            }
            break;

        case 3: // '\003'
            if(flag1)
            {
                byte byte4 = j >= 0 ? ((byte) (((byte)(j <= 0 ? 0 : 1)))) : -1;
                curve1.anchor1x += byte4;
                curve1.controlx += byte4;
                curve1.anchor2x += byte4;
                int k2 = -2 * byte4;
                curve2.anchor1x += k2;
                curve2.controlx += k2;
                curve2.anchor2x += k2;
            } else
            {
                byte byte5 = l >= 0 ? ((byte) (((byte)(l <= 0 ? 0 : 1)))) : -1;
                curve1.anchor1y += byte5;
                curve1.controly += byte5;
                curve1.anchor2y += byte5;
                int l2 = -2 * byte5;
                curve2.anchor1y += l2;
                curve2.controly += l2;
                curve2.anchor2y += l2;
            }
            break;
        }
        AddCurve(CurveReverse(curve1), true);
        AddCurve(curve2, true);
        if(!strokeInited)
        {
            lStartPt.x = curve1.anchor1x;
            lStartPt.y = curve1.anchor1y;
            startOrigin.x = curve.anchor1x;
            startOrigin.y = curve.anchor1y;
            rStartPt.x = curve2.anchor1x;
            rStartPt.y = curve2.anchor1y;
            strokeInited = true;
        } else
        {
            AddEdge(new Point(curve1.anchor1x, curve1.anchor1y), lCurPt);
            AddEdge(rCurPt, new Point(curve2.anchor1x, curve2.anchor1y));
        }
        lCurPt.x = curve1.anchor2x;
        lCurPt.y = curve1.anchor2y;
        curOrigin.x = curve.anchor2x;
        curOrigin.y = curve.anchor2y;
        rCurPt.x = curve2.anchor2x;
        rCurPt.y = curve2.anchor2y;
    }

    final void BeginStroke(int i, RColor rcolor)
    {
        strokeInited = false;
        lineThickness = Math.max(display.antialias ? 4 : 1, i);
        isThick = lineThickness > 3;
        strokeColor = rcolor;
        sCurPt.x = sCurPt.y = 0x80000000;
    }

    final void AddStrokeCurve(Curve curve)
    {
label0:
        {
label1:
            {
                Curve curve1;
label2:
                {
                    sCurPt.x = curve.anchor2x;
                    sCurPt.y = curve.anchor2y;
                    if(curve.anchor1x == curve.anchor2x && curve.anchor1y == curve.anchor2y && curve.anchor1x == curve.controlx && curve.anchor1y == curve.controly)
                        return;
                    if(!isThick)
                        if(curve.isLine)
                        {
                            strokeThinLine(curve);
                            return;
                        } else
                        {
                            StrokeThinCurve(curve);
                            return;
                        }
                    if(!display.antialias || !curve.isLine)
                        break label0;
                    if(lineThickness != 4 && lineThickness != 12)
                        break label1;
                    curve1 = new Curve(curve);
                    if(curve1.anchor1x == curve1.anchor2x)
                    {
                        int i = curve1.anchor1y - curve1.anchor2y;
                        if((i <= 0 ? -i : i) > 12)
                        {
                            curve1.anchor1x = curve1.anchor2x = (curve1.anchor1x & -4) + 2;
                            break label2;
                        }
                    }
                    if(curve1.anchor1y == curve1.anchor2y)
                    {
                        int j = curve1.anchor1x - curve1.anchor2x;
                        if((j <= 0 ? -j : j) > 12)
                            curve1.anchor1y = curve1.anchor2y = (curve1.anchor1y & -4) + 2;
                    }
                }
//                StrokeThickCurve(curve1);
                return;
            }
label3:
            {
                Curve curve2;
label4:
                {
                    if(lineThickness != 8)
                        break label3;
                    curve2 = new Curve(curve);
                    if(curve2.anchor1x == curve2.anchor2x)
                    {
                        int k = curve2.anchor1y - curve2.anchor2y;
                        if((k <= 0 ? -k : k) > 12)
                        {
                            curve2.anchor1x = curve2.anchor2x = curve2.anchor1x + 2 & -4;
                            break label4;
                        }
                    }
                    if(curve2.anchor1y == curve2.anchor2y)
                    {
                        int l = curve2.anchor1x - curve2.anchor2x;
                        if((l <= 0 ? -l : l) > 12)
                            curve2.anchor1y = curve2.anchor2y = curve2.anchor1y + 2 & -4;
                    }
                }
//                StrokeThickCurve(curve2);
                return;
            }
//            StrokeThickCurve(curve);
            return;
        }
//        StrokeThickCurve(curve);
    }

    final void EndStroke()
    {
        if(strokeInited)
        {
            if(startOrigin.x == curOrigin.x && startOrigin.y == curOrigin.y)
                if(!isThick)
                {
                    AddEdge(lStartPt, lCurPt);
                    AddEdge(rCurPt, rStartPt);
                    return;
                } else
                {
/*                    strokeJoin(lStartPt, lCurPt, curOrigin);
                    strokeJoin(rCurPt, rStartPt, curOrigin);*/
                    return;
                }
            if(!isThick)
            {
                AddEdge(lStartPt, rStartPt);
                AddEdge(rCurPt, lCurPt);
                return;
            } else
            {
/*                StrokeJoin(lStartPt, rStartPt, startOrigin);
                StrokeJoin(rCurPt, lCurPt, curOrigin);*/
                return;
            }
        }
        if(sCurPt.x != 0x80000000)
        {
            int i = lineThickness / 2;
            Point point = new Point(sCurPt.x, sCurPt.y);
            Point point1 = new Point(sCurPt.x, sCurPt.y);
            point.y -= i;
            point1.y += lineThickness - i;
            if(!isThick)
            {
                point.x -= i;
                point1.x -= i;
                AddEdge(point, point1);
                point.x += lineThickness - i;
                point1.x += lineThickness - i;
                AddEdge(point1, point);
                return;
            }
/*            StrokeJoin(point, point1, sCurPt);
            StrokeJoin(point1, point, sCurPt);*/
        }
    }

}