simplegraphics.java

遗传算法改进神经网络源程序 该小程序可以添加条形码功能到你的网页或者applet上,这个applet把大写字母和数字转换为标准的条形码。

// Decompiled by DJ v3.7.7.81 Copyright 2004 Atanas Neshkov  Date: 2007-11-23 16:17:33
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   SimpleGraphics.java

package com.bokai.drawing;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;

// Referenced classes of package com.bokai.drawing:
//            FontGlyph, FontInfo, FontManager, SimpleColor, 
//            SimpleFont, SimpleFontMetrics, SimpleShape

public class SimpleGraphics
{

    private SimpleGraphics()
    {
        xOrigin = 0;
        yOrigin = 0;
        _color = new SimpleColor(0, 0, 0);
        _g = null;
    }

    public SimpleGraphics(Graphics g)
    {
        xOrigin = 0;
        yOrigin = 0;
        _color = new SimpleColor(0, 0, 0);
        _g = g;
    }

    private void binaryPrintBytes(byte abyte0[], int i, int j, int k)
    {
        String s = "";
        for(int l = 0; l <= k / 8; l++)
        {
            byte byte0 = abyte0[i + l];
            int i1 = 7;
            if(l == 0)
                i1 = 7 - j;
            int j1 = 0;
            if(l == k / 8)
                j1 = 7 - k % 8;
            for(int k1 = i1; k1 >= j1; k1--)
                if((byte0 >> k1 & 1) == 0)
                    s = s + "1";
                else
                    s = s + "0";

        }

    }

    public void clipRect(int i, int j, int k, int l)
    {
        if(_g != null)
        {
            _g.clipRect(i, j, k, l);
            return;
        } else
        {
            i += xOrigin;
            j += yOrigin;
            return;
        }
    }

    public static SimpleGraphics createInMemoryGraphics(int i, int j, boolean flag)
    {
        SimpleGraphics simplegraphics = new SimpleGraphics();
        simplegraphics._width = i;
        simplegraphics._height = j;
        simplegraphics._blackAndWhite = true;
        simplegraphics._cbx = (i + 7) / 8;
        byte abyte0[] = new byte[simplegraphics._cbx * j];
        for(int k = 0; k < abyte0.length; k++)
            abyte0[k] = -1;

        simplegraphics._bitmap = abyte0;
        return simplegraphics;
    }

    public static byte[] createRotatedBitmap(byte abyte0[], int i, int j, int k)
    {
        int l;
        int i1;
        switch(k)
        {
        case 90: // 'Z'
        case 270: 
            l = j;
            i1 = i;
            break;

        case 180: 
        default:
            l = i;
            i1 = j;
            break;
        }
        int j1 = (l + 7) / 8;
        byte abyte1[] = new byte[j1 * i1];
        int k1 = (i + 7) / 8;
        if(k == 90 || k == 270)
        {
            int l1 = 0;
            for(int j2 = 0; j2 < i1;)
            {
                int l2;
                byte byte0;
                int k3;
                int i4;
                if(k == 90)
                {
                    k3 = (i - 1 - j2) / 8;
                    i4 = (i - 1 - j2) % 8;
                    l2 = 0;
                    byte0 = 1;
                } else
                {
                    k3 = j2 / 8;
                    i4 = j2 % 8;
                    l2 = j - 1;
                    byte0 = -1;
                }
                for(int k4 = 0; k4 < j1;)
                {
                    abyte1[l1 + k4] = 0;
                    for(int l4 = 0; l4 < 8; l4++)
                    {
                        if(l2 + l4 * byte0 >= j || l2 + l4 * byte0 < 0)
                            break;
                        int j5 = (l2 + l4 * byte0) * k1 + k3;
                        abyte1[l1 + k4] |= ((abyte0[j5] & 128 >>> i4) >>> 8 - i4 - 1) << 8 - l4 - 1;
                    }

                    k4++;
                    l2 += 8 * byte0;
                }

                j2++;
                l1 += j1;
            }

        } else
        if(k == 180)
        {
            int i2 = l % 8;
            int k2 = i2 != 0 ? 8 - i2 : 0;
            int i3 = 0;
            int j3 = j1 * i1 - 1;
            for(int l3 = 0; l3 < i1;)
            {
                for(int j4 = 0; j4 < j1; j4++)
                {
                    abyte1[i3 + j4] = 0;
                    byte byte1 = abyte0[j3 - j4];
                    byte1 >>= k2;
                    byte1 &= ~_startBits[k2];
                    if(k2 != 0)
                        if(j4 != j1 - 1)
                            byte1 |= abyte0[j3 - j4 - 1] << i2;
                        else
                            byte1 |= 255 << i2;
                    for(int i5 = 0; i5 < 8; i5++)
                        if((byte1 & 1 << i5) != 0)
                            abyte1[i3 + j4] |= 1 << 8 - i5 - 1;

                }

                l3++;
                i3 += j1;
                j3 -= j1;
            }

        } else
        {
            System.arraycopy(abyte0, 0, abyte1, 0, j1 * i1);
        }
        return abyte1;
    }

    public byte[] detachBitmapBytes()
    {
        byte abyte0[] = _bitmap;
        _bitmap = null;
        return abyte0;
    }

    public void dispose()
    {
        if(_g != null)
        {
            _g.dispose();
            _g = null;
            return;
        } else
        {
            return;
        }
    }

    public void drawChars(char ac[], int i, int j, int k, int l)
    {
        if(_g != null)
        {
            _g.drawChars(ac, i, j, k, l);
            return;
        }
        SimpleFontMetrics simplefontmetrics = _fontInfo.getFontMetrics();
        k += xOrigin;
        l += yOrigin;
        int i1 = l - simplefontmetrics.getMaxAscent();
        for(int j1 = 0; j1 < j; j1++)
        {
            FontGlyph fontglyph = _fontInfo.getCharGlyph(ac[j1 + i]);
            if(fontglyph == null)
                fontglyph = _fontInfo.getDefaultCharGlyph();
            if(fontglyph != null)
            {
                drawGlyph(fontglyph, k, i1);
                k += fontglyph.width;
            }
        }

    }

    private void drawGlyph(FontGlyph fontglyph, int i, int j)
    {
        int k = (fontglyph.width + 7) / 8;
        if(i > _width - 1)
            return;
        if((i + fontglyph.width) - 1 < 0)
            return;
        int l;
        int j1;
        if(i < 0)
        {
            j1 = 0;
            l = -i;
        } else
        {
            j1 = i;
            l = 0;
        }
        int i1;
        int k1;
        if((i + fontglyph.width) - 1 > _width - 1)
        {
            k1 = _width - 1;
            i1 = fontglyph.width - 1 - ((i + fontglyph.width) - _width);
        } else
        {
            k1 = (i + fontglyph.width) - 1;
            i1 = fontglyph.width - 1;
        }
        if(j > _height - 1)
            return;
        if((j + fontglyph.height) - 1 < 0)
            return;
        int l1;
        int k2;
        if(j < 0)
        {
            k2 = 0;
            l1 = -j;
        } else
        {
            k2 = j;
            l1 = 0;
        }
        int l2;
        if((j + fontglyph.height) - 1 > _height - 1)
        {
            l2 = _height - 1;
            int i2 = fontglyph.height - 1 - ((j + fontglyph.height) - _height);
        } else
        {
            l2 = (j + fontglyph.height) - 1;
            int j2 = fontglyph.height - 1;
        }
        int i3 = l1 * k;
        int j3 = k2 * _cbx;
        int l3 = l1;
        for(int k3 = k2; k3 <= l2;)
        {
            inverseCopyArrayBits(_bitmap, j3, j1, k1, fontglyph.bitmap, i3, l, i1);
            i3 += k;
            j3 += _cbx;
            k3++;
            l3++;
        }

    }

    public void drawRect(int i, int j, int k, int l)
    {
        if(_g != null)
        {
            _g.drawRect(i, j, k, l);
            return;
        } else
        {
            i += xOrigin;
            j += yOrigin;
            return;
        }
    }

    public void fillRect(int i, int j, int k, int l)
    {
        if(_g != null)
        {
            _g.fillRect(i, j, k, l);
            return;
        }
        i += xOrigin;
        j += yOrigin;
        if(i > _width - 1)
            return;
        if((i + k) - 1 < 0)
            return;
        int i1;
        if(i < 0)
            i1 = 0;
        else
            i1 = i;
        int k1;
        if((i + k) - 1 > _width - 1)
            k1 = _width - 1;
        else
            k1 = (i + k) - 1;
        if(j > _height - 1)
            return;
        if((j + l) - 1 < 0)
            return;
        int j1;
        if(j < 0)
            j1 = 0;
        else
            j1 = j;
        int l1;
        if((j + l) - 1 > _height - 1)
            l1 = _height - 1;
        else
            l1 = (j + l) - 1;
        int i2 = i1 / 8;
        int j2 = k1 / 8;
        int k2 = i1 % 8;
        int l2 = k1 % 8;
        int i3 = _cbx * j1;
        for(int j3 = j1; j3 <= l1;)
        {
            if(i2 == j2)
            {
                setByteBits(i3 + i2, k2, l2);
            } else
            {
                setByteBits(i3 + i2, k2, 7);
                if(j2 - i2 > 1)
                    setBytes(i3 + i2 + 1, (i3 + j2) - 1);
                setByteBits(i3 + j2, 0, l2);
            }
            j3++;
            i3 += _cbx;
        }

    }

    public byte[] getBitmapBytes()
    {
        return _bitmap;
    }

    public SimpleShape getClip()
    {
        if(_g != null)
            return new SimpleShape(_g.getClip());
        else
            return null;
    }

    public SimpleColor getColor()
    {
        if(_g != null)
            return new SimpleColor(_g.getColor());
        else
            return _color;
    }

    public SimpleFont getFont()
    {
        return _font;
    }

    public SimpleFontMetrics getFontMetrics()
    {
        if(_g != null)
            return new SimpleFontMetrics(_g.getFontMetrics());
        else
            return _fontInfo.getFontMetrics();
    }

    public Graphics getGraphics()
    {
        return _g;
    }

    private static void inverseCopyArrayBits(byte abyte0[], int i, int j, int k, byte abyte1[], int l, int i1, int j1)
    {
        int k2 = k / 8;
        int l2 = k % 8;
        int i3 = j1 / 8;
        int j3 = j1 % 8;
        int k3 = 7;
        int l3 = 7;
        boolean flag = false;
        int j4 = j;
        int i4;
        for(int k4 = i1; j4 <= k; k4 += i4)
        {
            int k1 = j4 / 8;
            int l1 = j4 % 8;
            if(k1 == k2)
                k3 = l2;
            int i2 = k4 / 8;
            int j2 = k4 % 8;
            if(i2 == i3)
                l3 = j3;
            i4 = 1 + Math.min(k3 - l1, l3 - j2);
            inverseCopyByteBits(abyte0, i + k1, l1, abyte1, l + i2, j2, i4);
            j4 += i4;
        }

    }

    private static void inverseCopyByteBits(byte abyte0[], int i, int j, byte abyte1[], int k, int l, int i1)
    {
        int j1 = (l + i1) - 1;
        int k1 = (j + i1) - 1;
        byte byte0 = abyte1[k];
        if(l > j)
            byte0 <<= l - j;
        else
        if(l < j)
            byte0 >>= j - l;
        byte byte1 = (byte)(_startBits[j] | _endBits[k1]);
        byte0 &= ~byte1;
        byte0 = (byte)(~byte0);
        abyte0[i] &= byte0;
    }

    public boolean isInGraphicsMode()
    {
        return _g != null;
    }

    private static int normalize(int i, int j, int k)
    {
        if(i < j)
            i = j;
        else
        if(i > k)
            i = k;
        return i;
    }

    private void setByteBits(int i, int j, int k)
    {
        byte byte0 = (byte)(_startBits[j] | _endBits[k]);
        byte byte1 = (byte)(((_color.getRGB() & 0xffffff) != 0 ? 0xff : '\0') & ~byte0);
        _bitmap[i] &= byte1 | byte0;
    }

    private void setBytes(int i, int j)
    {
        byte byte0 = (byte)((_color.getRGB() & 0xffffff) != 0 ? 255 : '\0');
        for(int k = i; k <= j; k++)
            _bitmap[k] = byte0;

    }

    public void setClip(SimpleShape simpleshape)
    {
        if(_g != null)
        {
            _g.setClip(simpleshape.getShape());
            return;
        } else
        {
            return;
        }
    }

    public void setColor(SimpleColor simplecolor)
    {
        if(_g != null)
        {
            _g.setColor(simplecolor.getColor());
            return;
        } else
        {
            _color = simplecolor;
            return;
        }
    }

    public void setFont(SimpleFont simplefont)
    {
        _font = simplefont;
        if(_g != null)
        {
            _g.setFont(_font.realizeFont());
            return;
        } else
        {
            FontManager fontmanager = FontManager.getFontManager();
            _fontInfo = fontmanager.getFont(simplefont.getName(), simplefont.getStyle(), simplefont.getSize());
            return;
        }
    }

    public void setTransform(AffineTransform affinetransform)
    {
        if(_g != null)
            ((Graphics2D)_g).setTransform(affinetransform);
    }

    public void translate(int i, int j)
    {
        if(_g != null)
        {
            _g.translate(i, j);
            return;
        } else
        {
            xOrigin += i;
            yOrigin += j;
            return;
        }
    }

    public void verticalLine(int i, int j, int k)
    {
        if(_g != null)
            return;
        i += xOrigin;
        j += yOrigin;
        k += yOrigin;
        if(i < 0 || i > _width - 1)
            return;
        if(j > k)
        {
            int l = j;
            j = k;
            k = l;
        }
        j = normalize(j, 0, _height - 1);
        k = normalize(k, 0, _height - 1);
        int i1 = i / 8;
        int j1 = i % 8;
        int k1 = _cbx * j;
        for(int l1 = j; l1 <= k;)
        {
            setByteBits(k1 + i1, j1, j1);
            l1++;
            k1 += _cbx;
        }

    }

    private boolean _blackAndWhite;
    private byte _bitmap[];
    private int _width;
    private int _height;
    private int _cbx;
    private int xOrigin;
    private int yOrigin;
    private SimpleColor _color;
    private SimpleFont _font;
    private FontInfo _fontInfo;
    private Graphics _g;
    private static final byte _startBits[] = {
        0, -128, -64, -32, -16, -8, -4, -2
    };
    private static final byte _endBits[] = {
        127, 63, 31, 15, 7, 3, 1, 0
    };

}