/**
 *
 * 女医ハックデータパーサ
 * Copyright (C) 2008 id:yuaaaa
 *
 * $Id$
 */

#if PocketPC

#define CrazyDraw

#endif

using System;
using System.Collections.Generic;
using System.Text;

using JoyHack;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;

using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

using Font = System.Drawing.Font;


namespace JHDrawLib
{
    public class DrawJoyHack : IDisposable
    {
        private List<Phrase> lyr;
        private int _width, _height;
        private int _defaultFontSize;
        private int _timeCodeFix; //frames - set from datafile
        private int _timeUserFix; //frames - set from App
        private bool _strict;

        private drawCache[] cache = new drawCache[4];
        private Device dxdevice = null;

        public bool _debug;
        public bool disable_cache;

        public bool debug
        {
            get { return this._debug; }
            set {
                this.clear_cache();
                this._debug = value;
            }
        }

        public int width
        {
            get { return this._width; }
            set
            {
                if (value <= 0) { throw new ArgumentOutOfRangeException(); }
                this.clear_cache();
                this._width = value;
            }
        }

        public int height
        {
            get { return this._height; }
            set
            {
                if (value <= 0) { throw new ArgumentOutOfRangeException(); }
                this.clear_cache();
                this._height = value;
            }
        }

        public bool strict { get { return this._strict; } set { this._strict = value; } }

        public int defaultFontSize
        {
            get { return this._defaultFontSize; }
            set
            {
                if (value < 1 || System.Single.MaxValue < value) { throw new ArgumentOutOfRangeException(); }
                this.clear_cache();
                this._defaultFontSize = value;
            }
        }

        public int timeCodeFix
        {
            get { return this._timeCodeFix; }
            private set { this._timeCodeFix = value; }
        }

        public int timeUserFix
        {
            get { return this._timeUserFix; }
            set { this._timeUserFix = value; }
        }

        public DrawJoyHack(int width, int height)
        {
            this.lyr = new List<Phrase>();
            this.width = width;
            this.height = height;
            this.defaultFontSize = 30;
            this.timeCodeFix = 0;
            this.timeUserFix = 0;
            this.debug = false;
            this.disable_cache = false;
            this.strict = false;

            // PresentParameters。デバイスを作成する際に必須
            // どのような環境でデバイスを使用するかを設定する
            PresentParameters pp = new PresentParameters();

            // ウインドウモードなら true、フルスクリーンモードなら false を指定
            pp.Windowed = true;

            // スワップ効果。とりあえず「Discard」を指定。
            pp.SwapEffect = SwapEffect.Discard;

            System.Windows.Forms.Form frm = new System.Windows.Forms.Form();


            // 実際にデバイスを作成します。
            // 常に最高のパフォーマンスで作成を試み、
            // 失敗したら下位パフォーマンスで作成するようにしている。
            try
            {
                // ハードウェアによる頂点処理、ラスタライズを行う
                // 最高のパフォーマンスで処理を行えます。
                // ビデオカードによっては実装できない処理が存在します。
                this.dxdevice = new Device(0, DeviceType.Hardware, frm/*topLevelForm.Handle*/,
                    CreateFlags.HardwareVertexProcessing, pp);
            }
            catch (DirectXException ex1)
            {
                // 作成に失敗
                //Debug.WriteLine(ex1.ToString());
                try
                {
                    // ソフトウェアによる頂点処理、ハードウェアによるラスタライズを行う
                    this.dxdevice = new Device(0, DeviceType.Hardware, frm/*topLevelForm.Handle*/,
                        CreateFlags.SoftwareVertexProcessing, pp);
                }
                catch (DirectXException ex2)
                {
                    // 作成に失敗
                    //Debug.WriteLine(ex2.ToString());
                    try
                    {
                        // ソフトウェアによる頂点処理、ラスタライズを行う
                        // パフォーマンスはとても低いです。
                        // その代わり、ほとんどの処理を制限なく行えます。
                        this.dxdevice = new Device(0, DeviceType.Reference, frm/*topLevelForm.Handle*/,
                            CreateFlags.SoftwareVertexProcessing, pp);
                    }
                    catch (DirectXException ex3)
                    {
                        // 作成に失敗
                        // 事実上デバイスは作成できません。
                        throw new Exception(ex3.ToString());
                    }
                }
            }


        }

        public void clear_cache ()
        {
            this.cache = new drawCache[4];
        }

        public void load_data(string file)
        {
            this.load_data(file, Encoding.GetEncoding(932));
        }

        public void load_data ( string file , Encoding encode )
        {

            lyr = new List<Phrase>();
            this.clear_cache();

            FileStream fs = new FileStream(file, FileMode.Open);
            StreamReader sr = new StreamReader(fs, encode);

            int showline = 0; //index 0... (all_showline-1)
            int all_showline = 2; // 1...4

            string line;
            WordCond cond = new WordCond();

            cond.color = new ShowColor(
                new Color[8] {Color.White, Color.Black, Color.Red, Color.White,
                                        Color.White, Color.Black, Color.Red, Color.White}
                                        );

#if PocketPC
            cond.mainfont = new WordFont(
                new Font("MS Gothic", this.defaultFontSize, FontStyle.Regular), StringAlignment.Near, 1.0D);
            cond.rubyfont = new WordFont(
                new Font("MS Gothic", this.defaultFontSize / 2, FontStyle.Regular), StringAlignment.Near, 1.0D);
#else
            cond.mainfont = new WordFont(
                new Font("MS UI Gothic", this.defaultFontSize, FontStyle.Regular, GraphicsUnit.Pixel), StringAlignment.Near, 1.0D);
            cond.rubyfont = new WordFont(
                new Font("MS UI Gothic", this.defaultFontSize/2 , FontStyle.Regular, GraphicsUnit.Pixel), StringAlignment.Near, 1.0D);
#endif
  
            Alignment align = Alignment.Default;
            Timecode prevphr_endtime = new Timecode(0);

            float height = -1;
            int linenum = 0;

            while ((line = sr.ReadLine()) != null) {
                linenum++;

                try
                {

                    line = line.Replace("\r", "").Replace("\n", "");

                    if (line.IndexOf("<timeCodeFix>") >= 0 )
                    {
                        string timecodestr = line.Substring("<timeCodeFix>".Length);
                        if (timecodestr.Length == 0)
                        {
                            this.timeCodeFix = 0;
                        }
                        else if (timecodestr.Length == 8)
                        {
                            this.timeCodeFix = new Timecode(timecodestr).allFrames;
                        }
                        else if (timecodestr.Length == 9)
                        {
                            if (timecodestr.Substring(0, 1) == "-")
                            {
                                this.timeCodeFix = -(new Timecode(timecodestr.Substring(1, 8)).allFrames);
                            }
                            else
                            {
                                this.timeCodeFix = +(new Timecode(timecodestr.Substring(1, 8)).allFrames);
                            }
                        }
                        else
                        {
                            throw new JoyHackDataException("不正な<timeCodeFix>です: \"" + timecodestr + "\"");
                        }
                        continue;
                    }

                    if ( line.IndexOf("<x_align>") >= 0 )
                    {
                        string alignstr = line.Substring("<x_align>".Length);
                        byte align_i = byte.Parse(alignstr);
                        if (align_i < 0 || 3 < align_i) { throw new JoyHackDataException("不正な<x_align>です"); }
                        align = (Alignment)align_i;
                        continue;
                    }

                    if (line.IndexOf("<time>") >= 0)
                    {
                        Phrase p;
                        p = new Phrase(line, showline, all_showline, ref cond, align, prevphr_endtime, this.strict);
                        prevphr_endtime = p.getEndtime();
                        if (p.clear)
                        {
                            all_showline = p.all_showline;
                            showline = 0;
                            height = -1;
                        }
                        else
                        {
                            if (height < 0) { height = p.GetMaxHeight(); }
                            p.height = height;
                            showline = (++showline) % all_showline;
                        }
                        lyr.Add(p);

                    }
                }
                catch (JoyHackDataException e)
                {
                    if (!e.ignorable || this.strict)
                    {
                        fs.Close();
                        throw new JoyHackDataException(linenum.ToString() + " 行目: " + e.Message);
                    }
                }
                catch (Exception e)
                {
                    fs.Close();
                    throw new Exception( "[BUG] " + linenum.ToString() + " 行目: " + e.Message);
                }
            } //ReadLine while

            fs.Close();
        }

        public Timecode getFixedTimecode(Timecode time)
        {
            return new Timecode( System.Math.Max(0, time.allFrames - this.timeCodeFix - this.timeUserFix));
        }
/*
        public void drawENT(Graphics g, long millisecond)
        {
            Timecode t = Timecode.FromMillisecond(millisecond);
            this.drawENT(g, t);
        }
*/

        public int getDrawPhraseList(Timecode t, out List<DrawPhraseCond> drawphrlist)
        {

            drawphrlist = new List<DrawPhraseCond>();

            if (this.lyr.Count == 0) { return -1; }

            int i;
            for (i = this.lyr.Count; i >0; i--)
            {
                if (this.lyr[i-1].getStarttime() < t) { break; }
            }
            i = i - 1; //Now Playing or Last Played

            int l_showlines;
            Phrase[] drawTemp = { null, null, null, null };
            bool playing_i = false;

            if (i >= 0)
            {
                if (this.lyr[i].getEndtime() >= t)
                { // Now Playing
                    playing_i = true;
                    if (this.lyr[i].clear) { return i; }
                }
                l_showlines = this.lyr[i].all_showline;

                if (l_showlines >= 2 || playing_i)
                {
                    if (!this.lyr[i].clear) {
                        drawTemp[this.lyr[i].showline] = this.lyr[i];
                    }
                }

                if (l_showlines >= 3 && !this.lyr[i].clear)
                {
                    if (i - 1 >= 0)
                    {
                        if (!this.lyr[i - 1].clear)
                        {
                            drawTemp[this.lyr[i-1].showline] = this.lyr[i-1];
                            if (i - 2 >= 0 && l_showlines >= 4)
                            {
                                if (!this.lyr[i - 2].clear)
                                {
                                    drawTemp[this.lyr[i-2].showline] = this.lyr[i-2];
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                //if (i + 1 >= this.lyr.Count) { throw new Exception("空の歌詞データです"); }
                l_showlines = this.lyr[i + 1].all_showline;
            }

            if (i + 1 < this.lyr.Count)
            {
                if (!playing_i || l_showlines >= 2)
                {
                    if (!this.lyr[i + 1].clear) { drawTemp[this.lyr[i+1].showline] = this.lyr[i+1]; }
                }
            }

            for (int cnt = 0; cnt < l_showlines; cnt++)
            {
                if (drawTemp[cnt] != null)
                {
                    drawphrlist.Add(new DrawPhraseCond(drawTemp[cnt], (int)(this.height - drawTemp[cnt].height * 1.8 * (drawTemp[cnt].all_showline - cnt) - 10)));
                }
            }
            return i;
        }

        //public delegate void DrawPhraseProc(Phrase p, Timecode fixedTime, int y);

        // 戻り値:
        //     全長
        private int getWordsWidth(ref List<Rectangle> width_arr, Phrase phr, Graphics g)
        {
            int all_width = 0;

#if PocketPC
            Encoding sjisEnc = Encoding.GetEncoding("Shift_JIS");
            for (int i = 0; i < phr.words.Count; i++)
            {
                int wid = (int)(10 * 96 / 72) * sjisEnc.GetByteCount(phr.words[i].str);
                all_width += wid;
                width_arr.Add(new Rectangle(0, 0, wid, (int)(20 * 96 / 72)));
            }

#else
            StringFormat allsf = new StringFormat();
            allsf.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
            allsf.Trimming = StringTrimming.None;

            for (int i = 0; i < phr.words.Count; i++)
            {
                if (phr.words[i].str.Length == 0)
                {
                    width_arr.Add(new Rectangle(0, 0, 0, 0));
                    all_width += 0;
                    continue;
                }

                allsf.SetMeasurableCharacterRanges(
                    new CharacterRange[] { new CharacterRange(0, phr.words[i].str.Length) });

                Region[] rrr = g.MeasureCharacterRanges
                    (phr.words[i].str.Replace(' ', '_').Replace('　' /*full-width space*/, '駄'),
                    phr.words[i].cond.mainfont.font, new RectangleF(0, 0, this.width, this.height), allsf);
                Rectangle rrrect = Rectangle.Truncate(rrr[0].GetBounds(g));

                rrrect.Width = (int)(rrrect.Width * phr.words[i].cond.mainfont.adjust_width);
                rrrect.Width += 2;

                if (phr.words[i].cond.width >= 0)
                {
                    rrrect.Width = phr.words[i].cond.width;
                }

                all_width += rrrect.Width;
                width_arr.Add(rrrect);
            }
#endif

            return all_width;

        }

#if CrazyDraw
        private void drawWord_base(Graphics g_base, Word w, Rectangle strrect, float maxheight, int x, int y)
        {

            g_base.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.Blue), x, y, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            return;
        }

        private void drawWord_effe(Graphics g_effe, Word w, Rectangle strrect, float maxheight, int x, int y)
        {

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x - 1, y - 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x - 1, y + 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x + 1, y - 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x + 1, y + 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.Red), x, y, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            return;
        }
#endif

        private void drawWord(Graphics g_base, Graphics g_effe, Word w, Rectangle strrect, float maxheight, int x, int y)
        {

#if PocketPC
            Graphics g_test = DrawJoyHack.getNotNull<Graphics>(g_base, g_effe);
            strrect.Offset(x, y);
            g_test.DrawRectangle(new Pen(Color.Yellow), strrect);

            x -= 4;

            if ( g_base != null )
            {
                this.drawWord_base( g_base, w, strrect, maxheight, x, y );
            }

            if ( g_effe != null )
            {
                this.drawWord_effe( g_effe, w, strrect, maxheight, x, y );
            }

            return;
#else

            if (g_base == null || g_effe == null)
            {
                throw new NullReferenceException();
            }

            Font fnt = w.cond.mainfont.font;
            StringFormat sf = new StringFormat();

            sf.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
            sf.Trimming = StringTrimming.None;
            sf.LineAlignment = w.cond.mainfont.line_align;

            int xoffset = strrect.X;

            x -= strrect.X;

            strrect.Offset(x, (int)(y + maxheight * 0.6));

            if (this.debug)
            { g_base.DrawRectangle(new Pen(Color.Red, 1), strrect); }

            GraphicsPath path = new GraphicsPath();
            path.AddString(w.str, fnt.FontFamily, (int)fnt.Style, strrect.Height,
                new Rectangle(x, strrect.Y, this.width - x, (int)maxheight), sf);

            Pen p = new Pen(w.cond.color[1], 5);
            // RecENT の不具合？ - Tik (2007年04月10日 22時22分26秒)
            p.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;

            g_base.DrawPath(p, path);
            g_base.FillPath(new SolidBrush(w.cond.color[0]), path);

            p.Color = w.cond.color[3];
            g_effe.DrawPath(p, path);
            g_effe.FillPath(new SolidBrush(w.cond.color[2]), path);

            if (!String.IsNullOrEmpty(w.ruby))
            {
                Font rubyfont = w.cond.rubyfont.font;

                StringFormat sfr = new StringFormat();
                sfr.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
                sfr.Trimming = StringTrimming.None;

                sfr.SetMeasurableCharacterRanges(new CharacterRange[] { new CharacterRange(0, w.ruby.Length) });
                Region[] regiruby = g_base.MeasureCharacterRanges(w.ruby, rubyfont, new RectangleF(0, 0, this.width, this.height), sfr);
                Rectangle recruby = Rectangle.Truncate(regiruby[0].GetBounds(g_base));

                sfr.LineAlignment = w.cond.rubyfont.line_align;

                if (recruby.Height > 0)
                {
                    recruby.Width = (int)(recruby.Width * w.cond.rubyfont.adjust_width);

                    if (recruby.Width < strrect.Width) { sfr.Alignment = StringAlignment.Center; }
                    else { sfr.Alignment = StringAlignment.Near; }

                    if (this.debug)
                    { g_base.DrawRectangle(new Pen(Color.Blue, 1), new Rectangle(x + xoffset, y, strrect.Width, (int)(maxheight * 0.6))); }

                    GraphicsPath path_r = new GraphicsPath();
                    //strrect.Offset(0, -(fnt.Height / 2) - 3);
                    //path_r.AddString(w.ruby, fnt.FontFamily, (int)fnt.Style, fnt.Height / 2, strrect, sfr);
                    path_r.AddString(w.ruby, rubyfont.FontFamily, (int)rubyfont.Style,
                        recruby.Height, new Rectangle(x + xoffset, y, strrect.Width, (int)(maxheight * 0.6)), sfr);

                    Pen pr = new Pen(w.cond.color[5], 2);
                    pr.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;

                    g_base.DrawPath(pr, path_r);
                    g_base.FillPath(new SolidBrush(w.cond.color[4]), path_r);

                    pr.Color = w.cond.color[7];
                    g_effe.DrawPath(pr, path_r);
                    g_effe.FillPath(new SolidBrush(w.cond.color[6]), path_r);
                }
            }
#endif
        }

        public void drawPhraseUsingCache_DX(Bitmap bmp_moto, DrawPhraseCond phrcond, Timecode time)
        {
            Phrase phr = phrcond.phr;

            if (phr.clear) { return; }
            Surface sur = new Surface(this.dxdevice, bmp_moto, Pool.Managed);
            //Microsoft.DirectX.Direct3D.
            Texture tex = new Texture(this.dxdevice, bmp_moto, Usage.None, Pool.Default);
            this.dxdevice.SetTexture(0, tex);
        }


        public void drawPhraseUsingCache(Graphics g_moto, DrawPhraseCond phrcond, Timecode time)
        {

#if PocketPC
            throw new NotImplementedException("drawPhraseUsingCache はPocketPCでは使用できません");
#else
            
            Phrase phr = phrcond.phr;
            int y = phrcond.y;

            const System.Drawing.Imaging.PixelFormat pixelfmt
#if PocketPC
             = System.Drawing.Imaging.PixelFormat.Format24bppRgb;
#else
             = System.Drawing.Imaging.PixelFormat.Format32bppArgb;
#endif


            if (phr.clear) { return; }


            if (this.cache[phr.showline].phr != phr || this.disable_cache) //not hit...
            {
                
                this.cache[phr.showline] = new drawCache(phr);


                //base
                Bitmap bmp1 = new Bitmap(this.width, this.height, pixelfmt);
                Graphics g_base = Graphics.FromImage(bmp1);
                this.cache[phr.showline].bmp_base = bmp1;

                //effected
                Bitmap bmp2 = new Bitmap(this.width, this.height, pixelfmt);
                Graphics g_effe = Graphics.FromImage(bmp2);
                this.cache[phr.showline].bmp_effe = bmp2;

#if !PocketPC

                g_base.SmoothingMode = SmoothingMode.AntiAlias;
                g_base.PixelOffsetMode = PixelOffsetMode.HighQuality;

                g_effe.SmoothingMode = SmoothingMode.AntiAlias;
                g_effe.PixelOffsetMode = PixelOffsetMode.HighQuality;
#endif
                List<int> drawedX = this.drawPhrase(g_base, g_effe, phrcond);

                this.cache[phr.showline].drawed_X = drawedX;

            }
            else
            {
                if (this.debug)
                    g_moto.DrawString("HIT! " + phr.showline.ToString(), new Font(FontFamily.GenericMonospace, 20, FontStyle.Regular), 
                        new SolidBrush(Color.HotPink), 10, 50 + 20 * phr.showline);
            }

            if (phr.words.Count + 1 != this.cache[phr.showline].drawed_X.Count)
            {
                throw new Exception("ワード数とキャッシュの対応がおかしいです");
            }

            int afterx = this.getDrawPosX(phr, this.cache[phr.showline].drawed_X, time);

            g_moto.DrawImage(this.cache[phr.showline].bmp_base, afterx, 0, new Rectangle(afterx, 0, this.width - afterx, this.height), GraphicsUnit.Pixel);
            g_moto.DrawImageUnscaledAndClipped(this.cache[phr.showline].bmp_effe, new Rectangle(0, 0, afterx, this.height));

#endif
        }

        private static T getNotNull<T>(T obj1, T obj2)
        {
            T test = obj1;
            if (test == null) { test = obj2; }
            if (test == null) { throw new NullReferenceException(); }
            return test;
        }

        //Return: drawed_X
        public List<int> drawPhrase(Graphics g_base, Graphics g_effe, DrawPhraseCond phrcond)
        {
            if (phrcond.phr == null) { return null; }

            Graphics g_test = DrawJoyHack.getNotNull<Graphics>(g_base, g_effe);

            Phrase phr = phrcond.phr;

            if (phr.clear)
            {
                throw new ArgumentException("<clear>フレーズは描画できません");
            }

            List<int> drawedX = new List<int>(); //Returner

            List<Rectangle> width_arr = new List<Rectangle>();
            int all_width = this.getWordsWidth(ref width_arr, phr, g_test);

            int x = -1;
            Alignment align = phr.align;
            if (align == Alignment.Default)
            {
                if ((phr.all_showline % 2) == 0)
                {
                    if ((phr.showline % 2) == 0) { align = Alignment.Left; }
                    else
                    {
                        align = Alignment.Right;
                    }
                }
                else if (phr.all_showline == 3)
                {
                    if (phr.showline == 0) { align = Alignment.Left; }
                    else if (phr.showline == 1)
                    {
                        align = Alignment.Center;
                    }
                    else if (phr.showline == 2)
                    {
                        align = Alignment.Right;
                    }
                }
                else if (phr.all_showline == 1)
                {
                    align = Alignment.Left;
                }
            }

            switch (align)
            {
                case Alignment.Left:
                    x = 20;
                    break;
                case Alignment.Center:
                    x = Math.Max((this.width - all_width) / 2, 20);
                    break;
                case Alignment.Right:
                    x = Math.Max(this.width - 20 - all_width, 20);
                    break;
                default:
                    throw new Exception("表示行がなんかおかしいです");
                //break;
            }

            for (int i = 0; i < phr.words.Count; i++)
            {
                Word w = phr.words[i];

                int lsi;
                int oldX = x;

                Rectangle strrect = width_arr[i];
                if (w.str.Length == 0 || strrect.Width <= 0)
                {
                    //goto skip_drawing;
                    lsi = 0;
                }
                else
                {
                    this.drawWord(g_base, g_effe, w, strrect, phr.GetMaxHeight(), x, phrcond.y);
                    lsi = strrect.Width;
                }

                drawedX.Add(oldX);
                x = oldX + lsi;
            } //word loop end

            drawedX.Add(x);

            return drawedX;
        }

        public int getDrawPosX(Phrase phr, List<int>drawed_X, Timecode time)
        {
            if (phr.clear)
            {
                throw new ArgumentException("<clear>フレーズは描画できません");
            }

            int afterx;

            if (phr.getEndtime() < time)
            {
                afterx = this.width; //^^;
            }
            else
            {
                afterx = 0;
                for (int wcnt = 0; wcnt < phr.words.Count; wcnt++)
                {
                    if (phr.words[wcnt].time < time && time < phr.getWordEnd(phr.words[wcnt]))
                    {
                        float allf = (float)(phr.getWordEnd(phr.words[wcnt]).allFrames - phr.words[wcnt].time.allFrames);
                        int nowf = time.allFrames - phr.words[wcnt].time.allFrames;
                        afterx = drawed_X[wcnt]
                            + (int)((drawed_X[wcnt + 1] - drawed_X[wcnt]) * (nowf / allf));
                        break;
                    }
                    else if (phr.getWordEnd(phr.words[wcnt]) <= time)
                    {
                        afterx = drawed_X[wcnt + 1];
                    }
                }
            }

            if (afterx < 0) { afterx = 0; }
            if (afterx > this.width) { afterx = this.width; }

            return afterx;
        }

        public void Dispose()
        {
            if (this.dxdevice != null)
            {
                this.dxdevice.Dispose();
            }
        }

    }

    public struct DrawPhraseCond
    {
        public Phrase phr;
        public int y;

        public DrawPhraseCond(Phrase phrase, int y)
        {
            this.phr = phrase;
            this.y = y;
        }
    }

    public struct drawCache
    {
        public Phrase phr;
        public Bitmap bmp_base;
        public Bitmap bmp_effe;
        public List<int> drawed_X;

        public drawCache(Phrase phrase)
        {
            this.phr = phrase;
            this.bmp_base = null;
            this.bmp_effe = null;
            this.drawed_X = new List<int>();
        }
    }

}