public LogWriter(TextBoxBase textBox, string path, bool writeTimestamp, bool append, params TextWriter[] otherOutputs)
     : base(path, writeTimestamp, append, otherOutputs)
 {
     _textBox = textBox;
     _scrollTextBox = true;
     _textBox.MouseWheel += new MouseEventHandler(textBox_MouseWheel);
 }

		public TextNormalizer (TextBoxBase textboxbase) 
		{
			this.textboxbase = textboxbase;
			
			start_point = 0;
			end_point = Text.Length;
		}

        public SpellChecker(TextBoxBase textbox, string localeId)
        {
            this.textbox = textbox;
            this.localeId = localeId;

            baseDir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
        }

 public static void AppendText(TextBoxBase control, string text)
 {
     if (control.InvokeRequired)
         control.Invoke(new AppendTextDelegate(AppendText), control, text);
     else
         control.AppendText(text);
 }

        /// <summary>
        ///   Returns the index of the character under the specified 
        ///   point in the control, or the nearest character if there
        ///   is no character under the point.
        /// </summary>
        /// <param name = "textBox">The text box control to check.</param>
        /// <param name = "point">The point to find the character for, 
        ///   specified relative to the client area of the text box.</param>
        /// <returns></returns>
        internal static int CharFromPos(TextBoxBase textBox, Point point)
        {
            unchecked
            {
                // Convert the point into a DWord with horizontal position
                // in the loword and vertical position in the hiword:
                var xy = (point.X & 0xFFFF) + ((point.Y & 0xFFFF) << 16);
                // Get the position from the text box.
                var res =
                    NativeMethods.SendMessageInt(
                        textBox.Handle,
                        NativeMethods.EM_CHARFROMPOS,
                        IntPtr.Zero,
                        new IntPtr(xy)).ToInt32();

                // the Platform SDK appears to be incorrect on this matter.
                // the hiword is the line number and the loword is the index
                // of the character on this line
                var lineNumber = ((res & 0xFFFF) >> 16);
                var charIndex = (res & 0xFFFF);

                // Find the index of the first character on the line within
                // the control:
                var lineStartIndex =
                    NativeMethods.SendMessageInt(
                        textBox.Handle,
                        NativeMethods.EM_LINEINDEX,
                        new IntPtr(lineNumber),
                        IntPtr.Zero).ToInt32();
                // Return the combined index:
                return lineStartIndex + charIndex;
            }
        }

		public HotSpot(TextBoxBase control, int offset, int length)
		{
			if(control == null)
			{
				throw  new ArgumentNullException("control");
			}
			if(offset < 0)
			{
				throw  new ArgumentOutOfRangeException("offset", offset, "offset cannot be less than zero");
			}
			if (offset >= control.Text.Length)
			{
				throw new ArgumentOutOfRangeException("offset", offset, "offset must be shorter than text.");
			}
			if(length <= 0)
			{
				throw new ArgumentOutOfRangeException("length", offset, "length must be greater than zero");
			}
			if (offset + length > control.Text.Length)
			{
				throw new ArgumentOutOfRangeException("length", length, "length plus offset must be shorter than text.");
			}
			_control = control;
			_offset = offset;
			_text = _control.Text.Substring(_offset, length);
		}

        /// <summary>
        /// Creates a new instance of the <see cref="TextBoxWriter"/> class.
        /// </summary>
        /// <param name="b">The <see cref="TextBoxBase"/> that will be written to.</param>
        /// <exception cref="NullReferenceException">Thrown if the supplied TextBoxBase is null.</exception>
        public TextBoxWriter( TextBoxBase b )
        {
            if ( b == null )
                throw new NullReferenceException();

            textBox = b;
        }

 private static bool ShouldSelectToken(Match match, TextBoxBase label)
 {
     var start = match.Index;
     var end = start + match.Length;
     var caret = label.SelectionStart;
     return caret >= start && caret <= end;
 }

        public CustomPaintTextBox(TextBoxBase clientTextBox, SpellChecker checker)
        {
            //Set up the CustomPaintTextBox
            this.clientTextBox = clientTextBox;
            this.mySpellChecker = checker;

            //Create a bitmap with the same dimensions as the textbox
            myBitmap = new Bitmap(clientTextBox.Width, clientTextBox.Height);

            //Create the graphics object from this bitmpa...this is where we will draw the lines to start with
            bufferGraphics = Graphics.FromImage(this.myBitmap);
            bufferGraphics.Clip = new Region(clientTextBox.ClientRectangle);

            //Get the graphics object for the textbox.  We use this to draw the bufferGraphics
            textBoxGraphics = Graphics.FromHwnd(clientTextBox.Handle);

            //Assign a handle for this class and set it to the handle for the textbox
            this.AssignHandle(clientTextBox.Handle);

            //We also need to make sure we update the handle if the handle for the textbox changes
            //This occurs if wordWrap is turned off for a RichTextBox
            clientTextBox.HandleCreated += TextBoxBase_HandleCreated;

            //We need to add a handler to change the clip rectangle if the textBox is resized
            clientTextBox.ClientSizeChanged += TextBoxBase_ClientSizeChanged;

            //this.disposedValue = false;
        }

        public bool GetSpellCheck(TextBoxBase extendee)
        {
            if(this.textBoxes.Contains(extendee))
                return (bool)this.textBoxes[extendee];

            return false;
        }

 public void AddControl(TextBoxBase control)
 {
     control.KeyUp += new KeyEventHandler(control_KeyUp);
     control.MouseClick += new MouseEventHandler(control_MouseClick);
     control.GotFocus += new EventHandler(control_GotFocus);
     control.KeyDown += new KeyEventHandler(control_KeyDown);
 }

 public Editor(TextBoxBase tbb)
 {
     _TextBoxBase = tbb;
     _TextBoxBase.KeyDown += new KeyEventHandler(KeyDown);
     _TextBoxBase.KeyUp += new KeyEventHandler(KeyUp);
     _TextBoxBase.KeyPress += new KeyPressEventHandler(KeyPress);
 }

 public static void AppendText(TextBoxBase tb, string text)
 {
     if (tb == null) return;
     tb.SuspendLayout();
     tb.SelectionStart = tb.TextLength;
     tb.SelectedText = text;
     tb.ResumeLayout();
 }

 public TextBoxTracer(TextBoxBase t, StringCollection data)
 {
     this.txtLog = t;
     this.logData = data;
     writeAction = s => t.Invoke(new Action(() =>
     {
         t.Text += s;
     }));
 }

        public static void Add(TextBoxBase textBox, string message)
        {
            if (textBox.Text == "Log")
              {
            textBox.Text = string.Empty;
              }

              textBox.Text += DateTime.Now + OneSpace + Dash + OneSpace + message + Crlf;
        }

        /// <summary>
        /// Changes the output display control.
        /// </summary>
        /// <param name="output">The new output.</param>
        public void ChangeDisplay(TextBoxBase output)
        {
            if (output != null)
            {
                _output = output;

                Flush();
            }
        }

 public TextBoxBinding(TextBoxBase textBox, bool readOnly = false, bool nullable = true, bool longText = false)
 {
     this.TextBox = textBox;
     this.TextBox.Multiline = longText;
     this.TextBox.ReadOnly = readOnly;
       if (this.TextBox is TextBox && longText)
     (this.TextBox as TextBox).ScrollBars = ScrollBars.Vertical;
     this.Nullable = nullable;
 }

        /// <summary>
        /// Binds the specified text box
        /// </summary>
        /// <param name="txt"></param>
        /// <param name="dataSource"></param>
        /// <param name="dataMember"></param>
        /// <returns></returns>
        public static Binding BindText(TextBoxBase txt, object dataSource, string dataMember)
        {
            var binding = txt.DataBindings.Add("Text", dataSource, dataMember); //NOXLATE
            txt.TextChanged += (sender, e) =>
            {
                binding.WriteValue();
            };

            return binding;
        }

		public RetrieveHotSpotsEventArgs(TextBoxBase control)
		{
			if (control == null)
			{
				throw new ArgumentNullException();
			}
			_color = Color.Red;
			_control = control;
			_hotSpots = new List<HotSpot>();
		}

 public static bool ParseInputH(TextBoxBase control, out ulong value)
 {
     if (!ulong.TryParse(control.Text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out value))
     {
         control.Focus();
         control.SelectAll();
         return false;
     }
     return true;
 }