读写文本

ldap http://www.360doc.com/content/08/0220/09/48984_1055997.shtml
   


public class BookPageFactory {
          
            private File book_file = null;
            private MappedByteBuffer m_mbBuf = null;
            private int m_mbBufLen = 0;
            private int m_mbBufBegin = 0;
            private int m_mbBufEnd = 0;
            private String m_textCode = "GBK";
            private Bitmap m_book_bg = null;
            private int mWidth;
            private int mHeight;

            private Vector<String> m_lines = new Vector<String>();

            private int m_fontSize = 20;
            private int m_textColor = Color.BLACK;
            private int m_backColor = 0xffff9e85;
            private int marginWidth = 15;
            private int marginHeight = 20;

            private int mLineCount;
            private float mVisibleHeight;
            private float mVisibleWidth;
            private boolean m_isfirstPage,m_islastPage;

            // private int m_nLineSpaceing = 5;

            private Paint mPaint;

            public BookPageFactory(int w, int h) {
                    // TODO Auto-generated constructor stub
                    mWidth = w;
                    mHeight = h;
                  
                    mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
                    mPaint.setTextAlign(Align.LEFT);
                    mPaint.setTextSize(m_fontSize);
                    mPaint.setColor(m_textColor);
                    mVisibleWidth = mWidth - marginWidth * 2;
                    mVisibleHeight = mHeight - marginHeight * 2;
                    mLineCount = (int) (mVisibleHeight / m_fontSize);
            }
          
            /**
             * 读取本地图书
             *
             * @param filePath 文件路径
             * @throws IOException
             */
            public void openbook(String filePath) throws IOException {
                    book_file = new File(filePath);
                  
                    String encoding = FileLocalCache.getTextCode(filePath);
                    m_textCode = FileLocalCache.coverEncoding(encoding);
                  
                    long lLen = book_file.length();
                    m_mbBufLen = (int) lLen;
                  
                    m_mbBuf = new RandomAccessFile(book_file, "r").getChannel().map(
                                    FileChannel.MapMode.READ_ONLY, 0, lLen);
            }
          

            protected byte[] readParagraphBack(int nFromPos) {
                    int nEnd = nFromPos;
                    int i;
                    byte b0, b1;
                    if (m_textCode.equals("UTF-16LE")) {
                            i = nEnd - 2;
                            while (i > 0) {
                                    b0 = m_mbBuf.get(i);
                                    b1 = m_mbBuf.get(i + 1);
                                    if (b0 == 0x0a && b1 == 0x00 && i != nEnd - 2) {
                                            i += 2;
                                            break;
                                    }
                                    i--;
                            }

                    } else if (m_textCode.equals("UTF-16BE")) {
                            i = nEnd - 2;
                            while (i > 0) {
                                    b0 = m_mbBuf.get(i);
                                    b1 = m_mbBuf.get(i + 1);
                                    if (b0 == 0x00 && b1 == 0x0a && i != nEnd - 2) {
                                            i += 2;
                                            break;
                                    }
                                    i--;
                            }
                    } else {
                            i = nEnd - 1;
                            while (i > 0) {
                                    b0 = m_mbBuf.get(i);
                                    if (b0 == 0x0a && i != nEnd - 1) {
                                            i++;
                                            break;
                                    }
                                    i--;
                            }
                    }
                    if (i < 0)
                            i = 0;
                    int nParaSize = nEnd - i;
                    int j;
                    byte[] buf = new byte[nParaSize];
                    for (j = 0; j < nParaSize; j++) {
                            buf[j] = m_mbBuf.get(i + j);
                    }
                    return buf;
            }

            protected byte[] readParagraphForward(int nFromPos) {
                    int nStart = nFromPos;
                    int i = nStart;
                    byte b0, b1;
                    if (m_textCode.equals("UTF-16LE")) {
                            while (i < m_mbBufLen - 1) {
                                    b0 = m_mbBuf.get(i++);
                                    b1 = m_mbBuf.get(i++);
                                    if (b0 == 0x0a && b1 == 0x00) {
                                            break;
                                    }
                            }
                    } else if (m_textCode.equals("UTF-16BE")) {
                            while (i < m_mbBufLen - 1) {
                                    b0 = m_mbBuf.get(i++);
                                    b1 = m_mbBuf.get(i++);
                                    if (b0 == 0x00 && b1 == 0x0a) {
                                            break;
                                    }
                            }
                    } else {
                            while (i < m_mbBufLen) {
                                    b0 = m_mbBuf.get(i++);
                                    if (b0 == 0x0a) {
                                            break;
                                    }
                            }
                    }
                    int nParaSize = i - nStart;
                    byte[] buf = new byte[nParaSize];
                    for (i = 0; i < nParaSize; i++) {
                            buf[i] = m_mbBuf.get(nFromPos + i);
                    }
                    return buf;
            }
          
            /**
             * next page
             */
            protected Vector<String> pageDown() {
                    String strParagraph = "";
                    Vector<String> lines = new Vector<String>();
                    while (lines.size() < mLineCount && m_mbBufEnd < m_mbBufLen) {
                            byte[] paraBuf = readParagraphForward(m_mbBufEnd);
                            m_mbBufEnd += paraBuf.length;
                            try {
                                    strParagraph = new String(paraBuf, m_textCode);
                            } catch (UnsupportedEncodingException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                            }
                            String strReturn = "";
                            if (strParagraph.indexOf("\r\n") != -1) {
                                    strReturn = "\r\n";
                                    strParagraph = strParagraph.replaceAll("\r\n", "");
                            } else if (strParagraph.indexOf("\n") != -1) {
                                    strReturn = "\n";
                                    strParagraph = strParagraph.replaceAll("\n", "");
                            }

                            if (strParagraph.length() == 0) {
                                    lines.add(strParagraph);
                            }
                            while (strParagraph.length() > 0) {
                                    int nSize = mPaint.breakText(strParagraph, true, mVisibleWidth,
                                                    null);
                                    lines.add(strParagraph.substring(0, nSize));
                                    strParagraph = strParagraph.substring(nSize);
                                    if (lines.size() >= mLineCount) {
                                            break;
                                    }
                            }
                            if (strParagraph.length() != 0) {
                                    try {
                                            m_mbBufEnd -= (strParagraph + strReturn)
                                                            .getBytes(m_textCode).length;
                                    } catch (UnsupportedEncodingException e) {
                                            // TODO Auto-generated catch block
                                            e.printStackTrace();
                                    }
                            }
                    }
                    return lines;
            }

            protected void pageUp() {
                    if (m_mbBufBegin < 0)
                            m_mbBufBegin = 0;
                    Vector<String> lines = new Vector<String>();
                    String strParagraph = "";
                    while (lines.size() < mLineCount && m_mbBufBegin > 0) {
                            Vector<String> paraLines = new Vector<String>();
                            byte[] paraBuf = readParagraphBack(m_mbBufBegin);
                            m_mbBufBegin -= paraBuf.length;
                            try {
                                    strParagraph = new String(paraBuf, m_textCode);
                            } catch (UnsupportedEncodingException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                            }
                            strParagraph = strParagraph.replaceAll("\r\n", "");
                            strParagraph = strParagraph.replaceAll("\n", "");

                            if (strParagraph.length() == 0) {
                                    paraLines.add(strParagraph);
                            }
                            while (strParagraph.length() > 0) {
                                    int nSize = mPaint.breakText(strParagraph, true, mVisibleWidth,
                                                    null);
                                    paraLines.add(strParagraph.substring(0, nSize));
                                    strParagraph = strParagraph.substring(nSize);
                            }
                            lines.addAll(0, paraLines);
                    }
                    while (lines.size() > mLineCount) {
                            try {
                                    m_mbBufBegin += lines.get(0).getBytes(m_textCode).length;
                                    lines.remove(0);
                            } catch (UnsupportedEncodingException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                            }
                    }
                    m_mbBufEnd = m_mbBufBegin;
                    return;
            }

            public void prePage() throws IOException {
                    if (m_mbBufBegin <= 0) {
                            m_mbBufBegin = 0;
                            m_isfirstPage=true;
                            return;
                    }else m_isfirstPage=false;
                    m_lines.clear();
                    pageUp();
                    m_lines = pageDown();
            }

            public void nextPage() throws IOException {
                    if (m_mbBufEnd >= m_mbBufLen) {
                            m_islastPage=true;
                            return;
                    }else m_islastPage=false;
                    m_lines.clear();
                    m_mbBufBegin = m_mbBufEnd;
                    m_lines = pageDown();
            }

            public void onDraw(Canvas c) {
                    if (m_lines.size() == 0)
                            m_lines = pageDown();
                    if (m_lines.size() > 0) {
                            if (m_book_bg == null)
                                    c.drawColor(m_backColor);
                            else
                                    c.drawBitmap(m_book_bg, 0, 0, null);
                            int y = marginHeight;
                            for (String strLine : m_lines) {
                                    y += m_fontSize;
                                    c.drawText(strLine, marginWidth, y, mPaint);
                            }
                    }
                    float fPercent = (float) (m_mbBufBegin * 1.0 / m_mbBufLen);
                    DecimalFormat df = new DecimalFormat("#0.0");
                    String strPercent = df.format(fPercent * 100) + "%";
                  
                    int nPercentWidth = (int) mPaint.measureText("999.9%") + 1;
                    c.drawText(strPercent, mWidth - nPercentWidth, mHeight - 5, mPaint);
            }

            public void setBgBitmap(Bitmap BG) {
                    m_book_bg = BG;
            }
          
            public boolean isfirstPage() {
                    return m_isfirstPage;
            }
          
            public boolean islastPage() {
                    return m_islastPage;
            }
          
            public void setTextCode(String textCode){
                    this.m_textCode = textCode;
            }
    }