using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;

namespace Payroll.Controls
{
    public partial class HtmlRichTextBox : RichTextBox
    {
        public HtmlRichTextBox()
        {
            InitializeComponent();
        }


        private int updating = 0;
        private int oldEventMask = 0;

        /// <summary>
        /// Maintains performance while updating.
        /// </summary>
        /// <remarks>
        /// <para>
        /// It is recommended to call this method before doing
        /// any major updates that you do not wish the user to
        /// see. Remember to call EndUpdate when you are finished
        /// with the update. Nested calls are supported.
        /// </para>
        /// <para>
        /// Calling this method will prevent redrawing. It will
        /// also setup the event mask of the underlying richedit
        /// control so that no events are sent.
        /// </para>
        /// </remarks>

        public void BeginUpdate()
        {
            // Deal with nested calls.
            ++updating;

            if (updating > 1)
                return;

            // Prevent the control from raising any events.
            oldEventMask = SendMessage(new HandleRef(this, Handle),
                EM_SETEVENTMASK, 0, 0);

            // Prevent the control from redrawing itself.
            SendMessage(new HandleRef(this, Handle),
                WM_SETREDRAW, 0, 0);
        }

        /// <summary>
        /// Resumes drawing and event handling.
        /// </summary>
        /// <remarks>
        /// This method should be called every time a call is made
        /// made to BeginUpdate. It resets the event mask to it's
        /// original value and enables redrawing of the control.
        /// </remarks>
        public void EndUpdate()
        {
            // Deal with nested calls.
            --updating;

            if (updating > 0)
                return;

            // Allow the control to redraw itself.
            SendMessage(new HandleRef(this, Handle),
                WM_SETREDRAW, 1, 0);

            // Allow the control to raise event messages.
            SendMessage(new HandleRef(this, Handle),
                EM_SETEVENTMASK, 0, oldEventMask);
        }

        /// <summary>
        /// Returns true when the control is performing some 
        /// internal updates, specially when is reading or writing
        /// HTML text
        /// </summary>
        public bool InternalUpdating
        {
            get
            {
                return (updating != 0);
            }
        }

        #region Win32 Apis

        // Constants from the Platform SDK.
        private const int EM_FORMATRANGE = 1081;

        private const int WM_USER = 0x0400;
        private const int EM_GETCHARFORMAT = WM_USER + 58;
        private const int EM_SETCHARFORMAT = WM_USER + 68;

        private const int EM_SETEVENTMASK = 1073;
        private const int EM_GETPARAFORMAT = 1085;
        private const int EM_SETPARAFORMAT = 1095;
        private const int EM_SETTYPOGRAPHYOPTIONS = 1226;
        private const int WM_SETREDRAW = 11;
        private const int TO_ADVANCEDTYPOGRAPHY = 1;


        // Defines for EM_SETCHARFORMAT/EM_GETCHARFORMAT
        private const Int32 SCF_SELECTION = 0x0001;
        private const Int32 SCF_WORD = 0x0002;
        private const Int32 SCF_ALL = 0x0004;

        public const int LF_FACESIZE = 32;

        // Defines for STRUCT_CHARFORMAT member dwMask
        public const UInt32 CFM_BOLD = 0x00000001;
        public const UInt32 CFM_ITALIC = 0x00000002;
        public const UInt32 CFM_UNDERLINE = 0x00000004;
        public const UInt32 CFM_STRIKEOUT = 0x00000008;
        public const UInt32 CFM_PROTECTED = 0x00000010;
        public const UInt32 CFM_LINK = 0x00000020;
        public const UInt32 CFM_SIZE = 0x80000000;
        public const UInt32 CFM_COLOR = 0x40000000;
        public const UInt32 CFM_FACE = 0x20000000;
        public const UInt32 CFM_OFFSET = 0x10000000;
        public const UInt32 CFM_CHARSET = 0x08000000;
        public const UInt32 CFM_SUBSCRIPT = CFE_SUBSCRIPT | CFE_SUPERSCRIPT;
        public const UInt32 CFM_SUPERSCRIPT = CFM_SUBSCRIPT;

        // Defines for STRUCT_CHARFORMAT member dwEffects
        public const UInt32 CFE_BOLD = 0x00000001;
        public const UInt32 CFE_ITALIC = 0x00000002;
        public const UInt32 CFE_UNDERLINE = 0x00000004;
        public const UInt32 CFE_STRIKEOUT = 0x00000008;
        public const UInt32 CFE_PROTECTED = 0x00000010;
        public const UInt32 CFE_LINK = 0x00000020;
        public const UInt32 CFE_AUTOCOLOR = 0x40000000;
        public const UInt32 CFE_SUBSCRIPT = 0x00010000;		/* Superscript and subscript are */
        public const UInt32 CFE_SUPERSCRIPT = 0x00020000;		/*  mutually exclusive			 */

        public const byte CFU_UNDERLINENONE = 0x00;
        public const byte CFU_UNDERLINE = 0x01;
        public const byte CFU_UNDERLINEWORD = 0x02; /* (*) displayed as ordinary underline	*/
        public const byte CFU_UNDERLINEDOUBLE = 0x03; /* (*) displayed as ordinary underline	*/
        public const byte CFU_UNDERLINEDOTTED = 0x04;
        public const byte CFU_UNDERLINEDASH = 0x05;
        public const byte CFU_UNDERLINEDASHDOT = 0x06;
        public const byte CFU_UNDERLINEDASHDOTDOT = 0x07;
        public const byte CFU_UNDERLINEWAVE = 0x08;
        public const byte CFU_UNDERLINETHICK = 0x09;
        public const byte CFU_UNDERLINEHAIRLINE = 0x0A; /* (*) displayed as ordinary underline	*/

        public const int CFM_SMALLCAPS = 0x0040;			/* (*)	*/
        public const int CFM_ALLCAPS = 0x0080;			/* Displayed by 3.0	*/
        public const int CFM_HIDDEN = 0x0100;			/* Hidden by 3.0 */
        public const int CFM_OUTLINE = 0x0200;			/* (*)	*/
        public const int CFM_SHADOW = 0x0400;			/* (*)	*/
        public const int CFM_EMBOSS = 0x0800;			/* (*)	*/
        public const int CFM_IMPRINT = 0x1000;			/* (*)	*/
        public const int CFM_DISABLED = 0x2000;
        public const int CFM_REVISED = 0x4000;

        public const int CFM_BACKCOLOR = 0x04000000;
        public const int CFM_LCID = 0x02000000;
        public const int CFM_UNDERLINETYPE = 0x00800000;		/* Many displayed by 3.0 */
        public const int CFM_WEIGHT = 0x00400000;
        public const int CFM_SPACING = 0x00200000;		/* Displayed by 3.0	*/
        public const int CFM_KERNING = 0x00100000;		/* (*)	*/
        public const int CFM_STYLE = 0x00080000;		/* (*)	*/
        public const int CFM_ANIMATION = 0x00040000;		/* (*)	*/
        public const int CFM_REVAUTHOR = 0x00008000;

        // Font Weights
        public const short FW_DONTCARE = 0;
        public const short FW_THIN = 100;
        public const short FW_EXTRALIGHT = 200;
        public const short FW_LIGHT = 300;
        public const short FW_NORMAL = 400;
        public const short FW_MEDIUM = 500;
        public const short FW_SEMIBOLD = 600;
        public const short FW_BOLD = 700;
        public const short FW_EXTRABOLD = 800;
        public const short FW_HEAVY = 900;

        public const short FW_ULTRALIGHT = FW_EXTRALIGHT;
        public const short FW_REGULAR = FW_NORMAL;
        public const short FW_DEMIBOLD = FW_SEMIBOLD;
        public const short FW_ULTRABOLD = FW_EXTRABOLD;
        public const short FW_BLACK = FW_HEAVY;

        // PARAFORMAT mask values
        public const UInt32 PFM_STARTINDENT = 0x00000001;
        public const UInt32 PFM_RIGHTINDENT = 0x00000002;
        public const UInt32 PFM_OFFSET = 0x00000004;
        public const UInt32 PFM_ALIGNMENT = 0x00000008;
        public const UInt32 PFM_TABSTOPS = 0x00000010;
        public const UInt32 PFM_NUMBERING = 0x00000020;
        public const UInt32 PFM_OFFSETINDENT = 0x80000000;

        // PARAFORMAT numbering options
        public const UInt16 PFN_BULLET = 0x0001;

        // PARAFORMAT alignment options
        public const UInt16 PFA_LEFT = 0x0001;
        public const UInt16 PFA_RIGHT = 0x0002;
        public const UInt16 PFA_CENTER = 0x0003;



        // It makes no difference if we use PARAFORMAT or
        // PARAFORMAT2 here, so I have opted for PARAFORMAT2.
        [StructLayout(LayoutKind.Sequential)]
        public struct PARAFORMAT
        {
            public int cbSize;
            public uint dwMask;
            public short wNumbering;
            public short wReserved;
            public int dxStartIndent;
            public int dxRightIndent;
            public int dxOffset;
            public short wAlignment;
            public short cTabCount;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
            public int[] rgxTabs;

            // PARAFORMAT2 from here onwards.
            public int dySpaceBefore;
            public int dySpaceAfter;
            public int dyLineSpacing;
            public short sStyle;
            public byte bLineSpacingRule;
            public byte bOutlineLevel;
            public short wShadingWeight;
            public short wShadingStyle;
            public short wNumberingStart;
            public short wNumberingStyle;
            public short wNumberingTab;
            public short wBorderSpace;
            public short wBorderWidth;
            public short wBorders;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct CHARFORMAT
        {
            public int cbSize;
            public UInt32 dwMask;
            public UInt32 dwEffects;
            public Int32 yHeight;
            public Int32 yOffset;
            public Int32 crTextColor;
            public byte bCharSet;
            public byte bPitchAndFamily;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
            public char[] szFaceName;

            // CHARFORMAT2 from here onwards.
            public short wWeight;
            public short sSpacing;
            public Int32 crBackColor;
            public uint lcid;
            public uint dwReserved;
            public short sStyle;
            public short wKerning;
            public byte bUnderlineType;
            public byte bAnimation;
            public byte bRevAuthor;
            public byte bReserved1;
        }

        [DllImport("user32", CharSet = CharSet.Auto)]
        private static extern int SendMessage(HandleRef hWnd,
            int msg,
            int wParam,
            int lParam);

        [DllImport("user32", CharSet = CharSet.Auto)]
        private static extern int SendMessage(HandleRef hWnd,
            int msg,
            int wParam,
            ref PARAFORMAT lp);

        [DllImport("user32", CharSet = CharSet.Auto)]
        private static extern int SendMessage(HandleRef hWnd,
            int msg,
            int wParam,
            ref CHARFORMAT lp);

        #endregion

        //----------------------------
        // New, version 1.1
        public void SetSuperScript(bool bSet)
        {
            CHARFORMAT cf = this.CharFormat;

            if (bSet)
            {
                cf.dwMask |= CFM_SUPERSCRIPT;
                cf.dwEffects |= CFE_SUPERSCRIPT;
            }
            else
            {
                cf.dwEffects &= ~CFE_SUPERSCRIPT;
            }

            this.CharFormat = cf;
        }

        public void SetSubScript(bool bSet)
        {
            CHARFORMAT cf = this.CharFormat;

            if (bSet)
            {
                cf.dwMask |= CFM_SUBSCRIPT;
                cf.dwEffects |= CFE_SUBSCRIPT;
            }
            else
            {
                cf.dwEffects &= ~CFE_SUBSCRIPT;
            }

            this.CharFormat = cf;
        }

        public bool IsSuperScript()
        {
            CHARFORMAT cf = this.CharFormat;
            return ((cf.dwEffects & CFE_SUPERSCRIPT) == CFE_SUPERSCRIPT);
        }

        public bool IsSubScript()
        {
            CHARFORMAT cf = this.CharFormat;
            return ((cf.dwEffects & CFE_SUBSCRIPT) == CFE_SUBSCRIPT);
        }
        //----------------------------

        public PARAFORMAT ParaFormat
        {
            get
            {
                PARAFORMAT pf = new PARAFORMAT();
                pf.cbSize = Marshal.SizeOf(pf);

                // Get the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_GETPARAFORMAT,
                    SCF_SELECTION, ref pf);

                return pf;
            }

            set
            {
                PARAFORMAT pf = value;
                pf.cbSize = Marshal.SizeOf(pf);

                // Set the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_SETPARAFORMAT,
                    SCF_SELECTION, ref pf);
            }
        }

        public PARAFORMAT DefaultParaFormat
        {
            get
            {
                PARAFORMAT pf = new PARAFORMAT();
                pf.cbSize = Marshal.SizeOf(pf);

                // Get the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_GETPARAFORMAT,
                    SCF_ALL, ref pf);

                return pf;
            }

            set
            {
                PARAFORMAT pf = value;
                pf.cbSize = Marshal.SizeOf(pf);

                // Set the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_SETPARAFORMAT,
                    SCF_ALL, ref pf);
            }
        }

        public CHARFORMAT CharFormat
        {
            get
            {
                CHARFORMAT cf = new CHARFORMAT();
                cf.cbSize = Marshal.SizeOf(cf);

                // Get the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_GETCHARFORMAT,
                    SCF_SELECTION, ref cf);

                return cf;
            }

            set
            {
                CHARFORMAT cf = value;
                cf.cbSize = Marshal.SizeOf(cf);

                // Set the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_SETCHARFORMAT,
                    SCF_SELECTION, ref cf);
            }
        }

        public CHARFORMAT DefaultCharFormat
        {
            get
            {
                CHARFORMAT cf = new CHARFORMAT();
                cf.cbSize = Marshal.SizeOf(cf);

                // Get the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_GETCHARFORMAT,
                    SCF_ALL, ref cf);

                return cf;
            }

            set
            {
                CHARFORMAT cf = value;
                cf.cbSize = Marshal.SizeOf(cf);

                // Set the alignment.
                SendMessage(new HandleRef(this, Handle),
                    EM_SETCHARFORMAT,
                    SCF_ALL, ref cf);
            }
        }

        #region COLORREF helper functions

        // convert COLORREF to Color
        private Color GetColor(int crColor)
        {
            byte r = (byte)(crColor);
            byte g = (byte)(crColor >> 8);
            byte b = (byte)(crColor >> 16);

            return Color.FromArgb(r, g, b);
        }

        // convert COLORREF to Color
        private int GetCOLORREF(int r, int g, int b)
        {
            int r2 = r;
            int g2 = (g << 8);
            int b2 = (b << 16);

            int result = r2 | g2 | b2;

            return result;
        }

        private int GetCOLORREF(Color color)
        {
            int r = color.R;
            int g = color.G;
            int b = color.B;

            return GetCOLORREF(r, g, b);
        }
        #endregion


        #region "Get HTML text"

        // format states
        private enum ctformatStates
        {
            nctNone = 0, // none format applied
            nctNew = 1, // new format
            nctContinue = 2, // continue with previous format
            nctReset = 3 // reset format (close this tag)
        }

        private enum uMyREType
        {
            U_MYRE_TYPE_TAG,
            U_MYRE_TYPE_EMO,
            U_MYRE_TYPE_ENTITY,
        }

        private struct cMyREFormat
        {
            public uMyREType nType;
            public int nLen;
            public int nPos;
            public string strValue;
        }

        public string GetHTML(bool bHTML, bool bParaFormat)
        {
            //------------------------
            // working variables
            CHARFORMAT cf;
            PARAFORMAT pf;

            ctformatStates bold = ctformatStates.nctNone;
            ctformatStates bitalic = ctformatStates.nctNone;
            ctformatStates bstrikeout = ctformatStates.nctNone;
            ctformatStates bunderline = ctformatStates.nctNone;
            ctformatStates super = ctformatStates.nctNone;
            ctformatStates sub = ctformatStates.nctNone;

            ctformatStates bacenter = ctformatStates.nctNone;
            ctformatStates baleft = ctformatStates.nctNone;
            ctformatStates baright = ctformatStates.nctNone;
            ctformatStates bnumbering = ctformatStates.nctNone;

            string strFont = "";
            Int32 crFont = 0;
            Color color = new Color();
            int yHeight = 0;
            int i = 0;
            //-------------------------

            //-------------------------
            // to store formatting
            ArrayList colFormat = new ArrayList();

            cMyREFormat mfr;
            //-------------------------

            //-------------------------
            // ok, lets go
            int nStart, nEnd;
            string strHTML = "";

            this.HideSelection = true;
            this.BeginUpdate();

            nStart = this.SelectionStart;
            nEnd = this.SelectionLength;

            try
            {
                //--------------------------------
                // replace entities
                if (bHTML)
                {

                    char[] ch = { '&', '<', '>', '"', '\'' };
                    string[] strreplace = { "&amp;", "&lt;", "&gt;", "&quot;", "&apos;" };

                    for (i = 0; i < ch.Length; i++)
                    {
                        char[] ch2 = { ch[i] };

                        int n = this.Find(ch2, 0);
                        while (n != -1)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = n;
                            mfr.nLen = 1;
                            mfr.nType = uMyREType.U_MYRE_TYPE_ENTITY;
                            mfr.strValue = strreplace[i];

                            colFormat.Add(mfr);

                            n = this.Find(ch2, n + 1);
                        }
                    }
                }
                //--------------------------------

                string strT = "";

                int k = this.TextLength;
                char[] chtrim = { ' ', '\x0000' };

                //--------------------------------
                // this is an inefficient method to get text format
                // but RichTextBox doesn't provide another method to
                // get something like an array of charformat and paraformat
                //--------------------------------
                for (i = 0; i < k; i++)
                {
                    // select one character
                    this.Select(i, 1);
                    string strChar = this.SelectedText;

                    if (bHTML)
                    {
                        //-------------------------
                        // get format for this character
                        cf = this.CharFormat;
                        pf = this.ParaFormat;

                        string strfname = new string(cf.szFaceName);
                        strfname = strfname.Trim(chtrim);
                        //-------------------------


                        //-------------------------
                        // new font format ?
                        if ((strFont != strfname) || (crFont != cf.crTextColor) || (yHeight != cf.yHeight))
                        {
                            if (strFont != "")
                            {
                                // close previous <font> tag

                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "</font>";

                                colFormat.Add(mfr);
                            }

                            //-------------------------
                            // save this for cache
                            strFont = strfname;
                            crFont = cf.crTextColor;
                            yHeight = cf.yHeight;
                            //-------------------------

                            //-------------------------
                            // font size should be translate to 
                            // html size (Approximately)
                            double fsize = (double)yHeight / (double)(20 * 5);

                            //-------------------------

                            //-------------------------
                            // color object from COLORREF
                            color = GetColor(crFont);
                            //-------------------------

                            //-------------------------
                            // add <font> tag
                            mfr = new cMyREFormat();

                            string strcolor = string.Concat("#", (color.ToArgb() & 0x00FFFFFF).ToString("X6"));

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "<font face=\"" + strFont + "\" color=\"" + strcolor + "\" size=\"" + fsize + "\">";

                            colFormat.Add(mfr);
                            //-------------------------
                        }

                        //-------------------------
                        // are we in another line ?
                        if ((strChar == "\r") || (strChar == "\n"))
                        {
                            // yes?
                            // then, we need to reset paragraph format
                            // and character format
                            if (bParaFormat)
                            {
                                bnumbering = ctformatStates.nctNone;
                                baleft = ctformatStates.nctNone;
                                baright = ctformatStates.nctNone;
                                bacenter = ctformatStates.nctNone;
                            }

                            // close previous tags

                            // is italic? => close it
                            if (bitalic != ctformatStates.nctNone)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "</i>";

                                colFormat.Add(mfr);

                                bitalic = ctformatStates.nctNone;
                            }

                            // is bold? => close it
                            if (bold != ctformatStates.nctNone)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "</b>";

                                colFormat.Add(mfr);

                                bold = ctformatStates.nctNone;
                            }

                            // is underline? => close it
                            if (bunderline != ctformatStates.nctNone)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "</u>";

                                colFormat.Add(mfr);

                                bunderline = ctformatStates.nctNone;
                            }

                            // is strikeout? => close it
                            if (bstrikeout != ctformatStates.nctNone)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "</s>";

                                colFormat.Add(mfr);

                                bstrikeout = ctformatStates.nctNone;
                            }

                            // is super? => close it
                            if (super != ctformatStates.nctNone)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "</sup>";

                                colFormat.Add(mfr);

                                super = ctformatStates.nctNone;
                            }

                            // is sub? => close it
                            if (sub != ctformatStates.nctNone)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "</sub>";

                                colFormat.Add(mfr);

                                sub = ctformatStates.nctNone;
                            }
                        }

                        // now, process the paragraph format,
                        // managing states: none, new, continue {with previous}, reset
                        if (bParaFormat)
                        {
                            // align to center?
                            if (pf.wAlignment == PFA_CENTER)
                            {
                                if (bacenter == ctformatStates.nctNone)
                                    bacenter = ctformatStates.nctNew;
                                else
                                    bacenter = ctformatStates.nctContinue;
                            }
                            else
                            {
                                if (bacenter != ctformatStates.nctNone)
                                    bacenter = ctformatStates.nctReset;
                            }

                            if (bacenter == ctformatStates.nctNew)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "<p align=\"center\">";

                                colFormat.Add(mfr);
                            }
                            else if (bacenter == ctformatStates.nctReset)
                                bacenter = ctformatStates.nctNone;
                            //---------------------

                            //---------------------
                            // align to left ?
                            if (pf.wAlignment == PFA_LEFT)
                            {
                                if (baleft == ctformatStates.nctNone)
                                    baleft = ctformatStates.nctNew;
                                else
                                    baleft = ctformatStates.nctContinue;
                            }
                            else
                            {
                                if (baleft != ctformatStates.nctNone)
                                    baleft = ctformatStates.nctReset;
                            }

                            if (baleft == ctformatStates.nctNew)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "<p align=\"left\">";

                                colFormat.Add(mfr);
                            }
                            else if (baleft == ctformatStates.nctReset)
                                baleft = ctformatStates.nctNone;
                            //---------------------

                            //---------------------
                            // align to right ?
                            if (pf.wAlignment == PFA_RIGHT)
                            {
                                if (baright == ctformatStates.nctNone)
                                    baright = ctformatStates.nctNew;
                                else
                                    baright = ctformatStates.nctContinue;
                            }
                            else
                            {
                                if (baright != ctformatStates.nctNone)
                                    baright = ctformatStates.nctReset;
                            }

                            if (baright == ctformatStates.nctNew)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "<p align=\"right\">";

                                colFormat.Add(mfr);
                            }
                            else if (baright == ctformatStates.nctReset)
                                baright = ctformatStates.nctNone;
                            //---------------------

                            //---------------------
                            // bullet ?
                            if (pf.wNumbering == PFN_BULLET)
                            {
                                if (bnumbering == ctformatStates.nctNone)
                                    bnumbering = ctformatStates.nctNew;
                                else
                                    bnumbering = ctformatStates.nctContinue;
                            }
                            else
                            {
                                if (bnumbering != ctformatStates.nctNone)
                                    bnumbering = ctformatStates.nctReset;
                            }

                            if (bnumbering == ctformatStates.nctNew)
                            {
                                mfr = new cMyREFormat();

                                mfr.nPos = i;
                                mfr.nLen = 0;
                                mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                                mfr.strValue = "<li>";

                                colFormat.Add(mfr);
                            }
                            else if (bnumbering == ctformatStates.nctReset)
                                bnumbering = ctformatStates.nctNone;
                            //---------------------
                        }

                        //---------------------
                        // bold ?
                        if ((cf.dwEffects & CFE_BOLD) == CFE_BOLD)
                        {
                            if (bold == ctformatStates.nctNone)
                                bold = ctformatStates.nctNew;
                            else
                                bold = ctformatStates.nctContinue;
                        }
                        else
                        {
                            if (bold != ctformatStates.nctNone)
                                bold = ctformatStates.nctReset;
                        }

                        if (bold == ctformatStates.nctNew)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "<b>";

                            colFormat.Add(mfr);
                        }
                        else if (bold == ctformatStates.nctReset)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "</b>";

                            colFormat.Add(mfr);

                            bold = ctformatStates.nctNone;
                        }
                        //---------------------

                        //---------------------
                        // Italic
                        if ((cf.dwEffects & CFE_ITALIC) == CFE_ITALIC)
                        {
                            if (bitalic == ctformatStates.nctNone)
                                bitalic = ctformatStates.nctNew;
                            else
                                bitalic = ctformatStates.nctContinue;
                        }
                        else
                        {
                            if (bitalic != ctformatStates.nctNone)
                                bitalic = ctformatStates.nctReset;
                        }

                        if (bitalic == ctformatStates.nctNew)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "<i>";

                            colFormat.Add(mfr);
                        }
                        else if (bitalic == ctformatStates.nctReset)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "</i>";

                            colFormat.Add(mfr);

                            bitalic = ctformatStates.nctNone;
                        }
                        //---------------------

                        //---------------------
                        // strikeout
                        if ((cf.dwEffects & CFM_STRIKEOUT) == CFM_STRIKEOUT)
                        {
                            if (bstrikeout == ctformatStates.nctNone)
                                bstrikeout = ctformatStates.nctNew;
                            else
                                bstrikeout = ctformatStates.nctContinue;
                        }
                        else
                        {
                            if (bstrikeout != ctformatStates.nctNone)
                                bstrikeout = ctformatStates.nctReset;
                        }

                        if (bstrikeout == ctformatStates.nctNew)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "<s>";

                            colFormat.Add(mfr);
                        }
                        else if (bstrikeout == ctformatStates.nctReset)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "</s>";

                            colFormat.Add(mfr);

                            bstrikeout = ctformatStates.nctNone;
                        }
                        //---------------------

                        //---------------------
                        // underline ?
                        if ((cf.dwEffects & CFE_UNDERLINE) == CFE_UNDERLINE)
                        {
                            if (bunderline == ctformatStates.nctNone)
                                bunderline = ctformatStates.nctNew;
                            else
                                bunderline = ctformatStates.nctContinue;
                        }
                        else
                        {
                            if (bunderline != ctformatStates.nctNone)
                                bunderline = ctformatStates.nctReset;
                        }

                        if (bunderline == ctformatStates.nctNew)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "<u>";

                            colFormat.Add(mfr);
                        }
                        else if (bunderline == ctformatStates.nctReset)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "</u>";

                            colFormat.Add(mfr);

                            bunderline = ctformatStates.nctNone;
                        }
                        //---------------------

                        //---------------------
                        // superscript ?
                        if ((cf.dwEffects & CFE_SUPERSCRIPT) == CFE_SUPERSCRIPT)
                        {
                            if (super == ctformatStates.nctNone)
                                super = ctformatStates.nctNew;
                            else
                                super = ctformatStates.nctContinue;
                        }
                        else
                        {
                            if (super != ctformatStates.nctNone)
                                super = ctformatStates.nctReset;
                        }

                        if (super == ctformatStates.nctNew)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "<sup>";

                            colFormat.Add(mfr);
                        }
                        else if (super == ctformatStates.nctReset)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "</sup>";

                            colFormat.Add(mfr);

                            super = ctformatStates.nctNone;
                        }
                        //---------------------

                        //---------------------
                        // subscript ?
                        if ((cf.dwEffects & CFE_SUBSCRIPT) == CFE_SUBSCRIPT)
                        {
                            if (sub == ctformatStates.nctNone)
                                sub = ctformatStates.nctNew;
                            else
                                sub = ctformatStates.nctContinue;
                        }
                        else
                        {
                            if (sub != ctformatStates.nctNone)
                                sub = ctformatStates.nctReset;
                        }

                        if (sub == ctformatStates.nctNew)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "<sub>";

                            colFormat.Add(mfr);
                        }
                        else if (sub == ctformatStates.nctReset)
                        {
                            mfr = new cMyREFormat();

                            mfr.nPos = i;
                            mfr.nLen = 0;
                            mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                            mfr.strValue = "</sub>";

                            colFormat.Add(mfr);

                            sub = ctformatStates.nctNone;
                        }
                        //---------------------
                    }

                    strT += strChar;
                }

                if (bHTML)
                {
                    // close pending tags
                    if (bold != ctformatStates.nctNone)
                    {
                        mfr = new cMyREFormat();

                        mfr.nPos = i;
                        mfr.nLen = 0;
                        mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                        mfr.strValue = "</b>";

                        colFormat.Add(mfr);
                        //strT += "</b>";
                    }

                    if (bitalic != ctformatStates.nctNone)
                    {
                        mfr = new cMyREFormat();

                        mfr.nPos = i;
                        mfr.nLen = 0;
                        mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                        mfr.strValue = "</i>";

                        colFormat.Add(mfr);
                        //strT += "</i>";
                    }

                    if (bstrikeout != ctformatStates.nctNone)
                    {
                        mfr = new cMyREFormat();

                        mfr.nPos = i;
                        mfr.nLen = 0;
                        mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                        mfr.strValue = "</s>";

                        colFormat.Add(mfr);

                        //strT += "</s>";
                    }

                    if (bunderline != ctformatStates.nctNone)
                    {
                        mfr = new cMyREFormat();

                        mfr.nPos = i;
                        mfr.nLen = 0;
                        mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                        mfr.strValue = "</u>";

                        colFormat.Add(mfr);

                        //strT += "</u>";
                    }

                    if (super != ctformatStates.nctNone)
                    {
                        mfr = new cMyREFormat();

                        mfr.nPos = i;
                        mfr.nLen = 0;
                        mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                        mfr.strValue = "</sup>";

                        colFormat.Add(mfr);
                        //strT += "</sup>";
                    }

                    if (sub != ctformatStates.nctNone)
                    {
                        mfr = new cMyREFormat();

                        mfr.nPos = i;
                        mfr.nLen = 0;
                        mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                        mfr.strValue = "</sub>";

                        colFormat.Add(mfr);
                        //strT += "</sub>";
                    }

                    if (strFont != "")
                    {
                        // close pending font format
                        mfr = new cMyREFormat();

                        mfr.nPos = i;
                        mfr.nLen = 0;
                        mfr.nType = uMyREType.U_MYRE_TYPE_TAG;
                        mfr.strValue = "</font>";

                        colFormat.Add(mfr);
                    }
                }

                //--------------------------
                // now, reorder the formatting array
                k = colFormat.Count;
                for (i = 0; i < k - 1; i++)
                {
                    for (int j = i + 1; j < k; j++)
                    {
                        mfr = (cMyREFormat)colFormat[i];
                        cMyREFormat mfr2 = (cMyREFormat)colFormat[j];

                        if (mfr2.nPos < mfr.nPos)
                        {
                            colFormat.RemoveAt(j);
                            colFormat.Insert(i, mfr2);
                            j--;
                        }
                        else if ((mfr2.nPos == mfr.nPos) && (mfr2.nLen < mfr.nLen))
                        {
                            colFormat.RemoveAt(j);
                            colFormat.Insert(i, mfr2);
                            j--;
                        }
                    }
                }
                //--------------------------


                //--------------------------
                // apply format by replacing and inserting HTML tags
                // stored in the Format Array
                int nAcum = 0;
                for (i = 0; i < k; i++)
                {
                    mfr = (cMyREFormat)colFormat[i];

                    strHTML += strT.Substring(nAcum, mfr.nPos - nAcum) + mfr.strValue;
                    nAcum = mfr.nPos + mfr.nLen;
                }

                if (nAcum < strT.Length)
                    strHTML += strT.Substring(nAcum);
                //--------------------------
            }
            catch
            {
                //MessageBox.Show(ex.Message);
            }
            finally
            {
                //--------------------------
                // finish, restore
                this.SelectionStart = nStart;
                this.SelectionLength = nEnd;

                this.EndUpdate();
                this.HideSelection = false;
                //--------------------------
            }

            return strHTML;
        }
        #endregion

        #region "Add HTML text"
        public void AddHTML(string strHTML)
        {
            CHARFORMAT cf;
            PARAFORMAT pf;

            cf = this.DefaultCharFormat; // to apply character formatting
            pf = this.DefaultParaFormat; // to apply paragraph formatting

            char[] chtrim = { ' ', '\x0000' };

            this.HideSelection = true;
            this.BeginUpdate();

            try
            {
                // process text
                while (strHTML.Length > 0)
                {
                    string strData = strHTML;

                reinit:

                    // looking for start tags
                    int nStart = strHTML.IndexOf('<');
                    if (nStart >= 0)
                    {
                        if (nStart > 0)
                        {
                            // tag is not the first character, so
                            // we need to add text to control and continue
                            // looking for tags at the begining of the text
                            strData = strHTML.Substring(0, nStart);
                            strHTML = strHTML.Substring(nStart);
                        }
                        else
                        {
                            // ok, get tag value
                            int nEnd = strHTML.IndexOf('>', nStart);
                            if (nEnd > nStart)
                            {
                                if ((nEnd - nStart) > 0)
                                {
                                    string strTag = strHTML.Substring(nStart, nEnd - nStart + 1);
                                    strTag = strTag.ToLower();

                                    if (strTag == "<b>")
                                    {
                                        cf.dwMask |= CFM_WEIGHT | CFM_BOLD;
                                        cf.dwEffects |= CFE_BOLD;
                                        cf.wWeight = FW_BOLD;
                                    }
                                    else if (strTag == "<i>")
                                    {
                                        cf.dwMask |= CFM_ITALIC;
                                        cf.dwEffects |= CFE_ITALIC;
                                    }
                                    else if (strTag == "<u>")
                                    {
                                        cf.dwMask |= CFM_UNDERLINE | CFM_UNDERLINETYPE;
                                        cf.dwEffects |= CFE_UNDERLINE;
                                        cf.bUnderlineType = CFU_UNDERLINE;
                                    }
                                    else if (strTag == "<s>")
                                    {
                                        cf.dwMask |= CFM_STRIKEOUT;
                                        cf.dwEffects |= CFE_STRIKEOUT;
                                    }
                                    else if (strTag == "<sup>")
                                    {
                                        cf.dwMask |= CFM_SUPERSCRIPT;
                                        cf.dwEffects |= CFE_SUPERSCRIPT;
                                    }
                                    else if (strTag == "<sub>")
                                    {
                                        cf.dwMask |= CFM_SUBSCRIPT;
                                        cf.dwEffects |= CFE_SUBSCRIPT;
                                    }
                                    else if ((strTag.Length > 2) && (strTag.Substring(0, 2) == "<p"))
                                    {
                                        if (strTag.IndexOf("align=\"left\"") > 0)
                                        {
                                            pf.dwMask |= PFM_ALIGNMENT;
                                            pf.wAlignment = (short)PFA_LEFT;
                                        }
                                        else if (strTag.IndexOf("align=\"right\"") > 0)
                                        {
                                            pf.dwMask |= PFM_ALIGNMENT;
                                            pf.wAlignment = (short)PFA_RIGHT;
                                        }
                                        else if (strTag.IndexOf("align=\"center\"") > 0)
                                        {
                                            pf.dwMask |= PFM_ALIGNMENT;
                                            pf.wAlignment = (short)PFA_CENTER;
                                        }
                                    }
                                    else if ((strTag.Length > 5) && (strTag.Substring(0, 5) == "<font"))
                                    {
                                        string strFont = new string(cf.szFaceName);
                                        strFont = strFont.Trim(chtrim);
                                        int crFont = cf.crTextColor;
                                        int yHeight = cf.yHeight;
                                        double dHeight = yHeight;
                                        int nFace = strTag.IndexOf("face=");
                                        if (nFace > 0)
                                        {
                                            int nFaceEnd = strTag.IndexOf('\"', nFace + 6);
                                            if (nFaceEnd > nFace)
                                                strFont = strTag.Substring(nFace + 6, nFaceEnd - nFace - 6);
                                        }

                                        int nSize = strTag.IndexOf("size=");
                                        if (nSize > 0)
                                        {
                                            int nSizeEnd = strTag.IndexOf('\"', nSize + 6);
                                            if (nSizeEnd > nSize)
                                            {
                                                dHeight = double.Parse(strTag.Substring(nSize + 6, nSizeEnd - nSize - 6));
                                                dHeight *= (double)(20 * 5);
                                                yHeight = (int)dHeight;
                                            }
                                        }

                                        int nColor = strTag.IndexOf("color=");
                                        if (nColor > 0)
                                        {
                                            int nColorEnd = strTag.IndexOf('\"', nColor + 7);
                                            if (nColorEnd > nColor)
                                            {
                                                if (strTag.Substring(nColor + 7, 1) == "#")
                                                {
                                                    string strCr = strTag.Substring(nColor + 8, nColorEnd - nColor - 8);
                                                    int nCr = Convert.ToInt32(strCr, 16);

                                                    Color color = Color.FromArgb(nCr);

                                                    crFont = GetCOLORREF(color);
                                                }
                                                else
                                                {
                                                    crFont = int.Parse(strTag.Substring(nColor + 7, nColorEnd - nColor - 7));
                                                }
                                            }
                                        }

                                        cf.szFaceName = new char[LF_FACESIZE];
                                        strFont.CopyTo(0, cf.szFaceName, 0, Math.Min(LF_FACESIZE - 1, strFont.Length));
                                        //cf.szFaceName = strFont.ToCharArray(0, Math.Min(strFont.Length, LF_FACESIZE));
                                        cf.crTextColor = crFont;
                                        cf.yHeight = yHeight;

                                        cf.dwMask |= CFM_COLOR | CFM_SIZE | CFM_FACE;
                                        cf.dwEffects &= ~CFE_AUTOCOLOR;
                                    }
                                    else if (strTag == "<li>")
                                    {
                                        if (pf.wNumbering != PFN_BULLET)
                                        {
                                            pf.dwMask |= PFM_NUMBERING;
                                            pf.wNumbering = (short)PFN_BULLET;
                                        }
                                    }
                                    else if (strTag == "</b>")
                                    {
                                        cf.dwEffects &= ~CFE_BOLD;
                                        cf.wWeight = FW_NORMAL;
                                    }
                                    else if (strTag == "</i>")
                                    {
                                        cf.dwEffects &= ~CFE_ITALIC;
                                    }
                                    else if (strTag == "</u>")
                                    {
                                        cf.dwEffects &= ~CFE_UNDERLINE;
                                    }
                                    else if (strTag == "</s>")
                                    {
                                        cf.dwEffects &= ~CFM_STRIKEOUT;
                                    }
                                    else if (strTag == "</sup>")
                                    {
                                        cf.dwEffects &= ~CFE_SUPERSCRIPT;
                                    }
                                    else if (strTag == "</sub>")
                                    {
                                        cf.dwEffects &= ~CFE_SUBSCRIPT;
                                    }
                                    else if (strTag == "</font>")
                                    {
                                    }
                                    else if (strTag == "</p>")
                                    {
                                    }
                                    else if (strTag == "</li>")
                                    {
                                    }

                                    //-------------------------------
                                    // now, remove tag from HTML
                                    int nStart2 = strHTML.IndexOf("<", nEnd + 1);
                                    if (nStart2 > 0)
                                    {
                                        // extract partial data
                                        strData = strHTML.Substring(nEnd + 1, nStart2 - nEnd - 1);
                                        strHTML = strHTML.Substring(nStart2);
                                    }
                                    else
                                    {
                                        // get remain text and finish
                                        if ((nEnd + 1) < strHTML.Length)
                                            strData = strHTML.Substring(nEnd + 1);
                                        else
                                            strData = "";

                                        strHTML = "";
                                    }
                                    //-------------------------------s


                                    //-------------------------------
                                    // have we any continuos tag ?
                                    if (strData.Length > 0)
                                    {
                                        // yes, ok, goto to reinit
                                        if (strData[0] == '<')
                                            goto reinit;
                                    }
                                    //-------------------------------
                                }
                                else
                                {
                                    // we have not found any valid tag
                                    strHTML = "";
                                }
                            }
                            else
                            {
                                // we have not found any valid tag
                                strHTML = "";
                            }
                        }
                    }
                    else
                    {
                        // we have not found any tag
                        strHTML = "";
                    }

                    if (strData.Length > 0)
                    {
                        //-------------------------------
                        // replace entities
                        strData = strData.Replace("&amp;", "&");
                        strData = strData.Replace("&lt;", "<");
                        strData = strData.Replace("&gt;", ">");
                        strData = strData.Replace("&apos;", "'");
                        strData = strData.Replace("&quot;", "\"");
                        //-------------------------------

                        string strAux = strData; // use another copy

                        while (strAux.Length > 0)
                        {
                            //-----------------------
                            int nLen = strAux.Length;
                            //-----------------------

                            //-------------------------------
                            // now, add text to control
                            int nStartCache = this.SelectionStart;
                            string strt = strAux.Substring(0, nLen);

                            this.SelectedText = strt;
                            strAux = strAux.Remove(0, nLen);

                            this.SelectionStart = nStartCache;
                            this.SelectionLength = strt.Length;
                            //-------------------------------

                            //-------------------------------
                            // apply format
                            this.ParaFormat = pf;
                            this.CharFormat = cf;
                            //-------------------------------


                            // reposition to final
                            this.SelectionStart = this.TextLength + 1;
                            this.SelectionLength = 0;
                        }

                        // reposition to final
                        this.SelectionStart = this.TextLength + 1;
                        this.SelectionLength = 0;

                        //-------------------------------
                        // new paragraph requires to reset alignment
                        if ((strData.IndexOf("\r\n", 0) >= 0) || (strData.IndexOf("\n", 0) >= 0))
                        {
                            pf.dwMask = PFM_ALIGNMENT | PFM_NUMBERING;
                            pf.wAlignment = (short)PFA_LEFT;
                            pf.wNumbering = 0;
                        }
                        //-------------------------------
                    }
                } // while (strHTML.Length > 0)
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                // reposition to final
                this.SelectionStart = this.TextLength + 1;
                this.SelectionLength = 0;

                this.EndUpdate();
                this.HideSelection = false;
            }
        }
        #endregion

    }
}