customcontrol – Sanity Free Coding http://www.sanity-free.com Methods to the Madness Thu, 20 Nov 2025 04:45:11 +0000 en-US hourly 1 https://wordpress.org/?v=6.9.1 http://sanity-free.org/wp-content/uploads/2025/10/sanity-free-512-150x150.jpg customcontrol – Sanity Free Coding http://www.sanity-free.com 32 32 An IPAddress Control (the Win32 SysIPAddress32 control in C#) http://www.sanity-free.com/an_ipaddress_control_the_win32_sysipaddress32_control_in_csharp.html Sun, 30 Jul 2006 18:00:52 +0000 http://dev.sanity-free.org/?p=179 The Common Controls library from the Platform SDK provides a control that Microsoft failed to provide a .NET counterpart to: the IPAddress Control (known as SysIPAddress32).

Quite a while ago I wrote a C# / .NET control that wrapped the functionality of the SysIPAddress32 control from comctl32.dll

I had a much better implementation back then (with quite a few nice things included), but the hard drive that it lived on has since died, and I just haven’t wanted to spend the time putting all that stuff back into the control.

Some time after having written the “nice” version of this control, I posted the following code to another website. Now, it’s all I have left of the original. There is a known problem with the handle to the font being disposed incorrectly, but the code that fixed it, was given to me by a software engineer who worked at Microsoft that went by jfo, and I did a cut/paste of the solution without really paying much attention to it (kind of regretting that now…). You may notice all the system fonts will always be displayed in BOLD in the forms designer (even when the font is not set to bold). This goes away a runtime, it’s caused by an improperly disposed handle during design time.

Anyway, here it is, my IPAddress Control:

/******************************************************/
/*          NULLFX FREE SOFTWARE LICENSE              */
/******************************************************/
/*  IPAddressControl                                  */
/*  by: Steve Whitley                                 */
/*  © 2004 NullFX Software                            */
/*                                                    */
/* NULLFX SOFTWARE DISCLAIMS ALL WARRANTIES,          */
/* RESPONSIBILITIES, AND LIABILITIES ASSOCIATED WITH  */
/* USE OF THIS CODE IN ANY WAY, SHAPE, OR FORM        */
/* REGARDLESS HOW IMPLICIT, EXPLICIT, OR OBSCURE IT   */
/* IS. IF THERE IS ANYTHING QUESTIONABLE WITH REGARDS */
/* TO THIS SOFTWARE BREAKING AND YOU GAIN A LOSS OF   */
/* ANY NATURE, WE ARE NOT THE RESPONSIBLE PARTY. USE  */
/* OF THIS SOFTWARE CREATES ACCEPTANCE OF THESE TERMS */
/*                                                    */
/* USE OF THIS CODE MUST RETAIN ALL COPYRIGHT NOTICES */
/* AND LICENSES (MEANING THIS TEXT).                  */
/*                                                    */
/******************************************************/


namespace NullFX.Controls {
    using System;
    using System.Net;
    using System.Windows.Forms;
    using System.Runtime.InteropServices;
    using System.Diagnostics;
    using System.Drawing;
    [StructLayout(LayoutKind.Sequential)]
    public struct Nmhdr {
        public IntPtr HWndFrom;
        public UIntPtr IdFrom;
        public int Code;
    }
    [StructLayout(LayoutKind.Sequential)]
    public struct NmIPAddress {
        public Nmhdr Hdr;
        public int Field;
        public int Value;
    }
    [StructLayout(LayoutKind.Sequential)]
    public struct InitCommonControlsEX {
        public int Size;
        public int Icc;
    }
    public enum IPField { OctetOne = 0, OctetTwo = 1, OctetThree = 2, OctetFour = 3 }
    public delegate void FieldChangedHandler(object sender, FieldChangedEventArgs e);
    public class FieldChangedEventArgs : EventArgs {
        private int _field, _value;
        public int Field {
            get { return _field; }
        }
        public int Value {
            get { return _value; }
        }
        public FieldChangedEventArgs(int field, int value)
            : base() {
            _field = field;
            _value = value;
        }
    }
    public class IPAddressControl : TextBox {
        private const int WM_NOTIFY = 0x004E,
            WM_USER = 0x0400,
            WM_REFLECT = WM_USER + 0x1C00,
            IPN_FIRST = -860,
            IPM_SETRANGE = (WM_USER + 103),
            IPM_GETADDRESS = (WM_USER + 102),
            IPM_SETADDRESS = (WM_USER + 101),
            IPM_CLEARADDRESS = (WM_USER + 100),
            IPM_ISBLANK = (WM_USER + 105),
            ICC_INTERNET_CLASSES = 0x00000800,
            CS_VREDRAW = 0x0001,
            CS_HREDRAW = 0x0002,
            CS_DBLCLKS = 0x0008,
            CS_GLOBALCLASS = 0x4000,
            WS_CHILD = 0x40000000,
            WS_VISIBLE = 0x10000000,
            WS_TABSTOP = 0x00010000,
            WS_EX_RIGHT = 0x00001000,
            WS_EX_LEFT = 0x00000000,
            WS_EX_RTLREADING = 0x00002000,
            WS_EX_LTRREADING = 0x00000000,
            WS_EX_LEFTSCROLLBAR = 0x00004000,
            WS_EX_RIGHTSCROLLBAR = 0x00000000,
            WS_EX_NOPARENTNOTIFY = 0x00000004,
            WS_EX_CLIENTEDGE = 0x00000200;
        private int[] values = new int[4];
        bool initialized = false;		
        public event FieldChangedHandler FieldChanged;
        public IPAddressControl()
            : base() {
            for(int i = 0; i < 4; i++)
                values[i] = 0;
        }
        [DllImport("comctl32")]
        static extern bool InitCommonControlsEx(ref InitCommonControlsEX lpInitCtrls);

        protected virtual void OnFieldChanged(FieldChangedEventArgs e) {
            if(FieldChanged != null) FieldChanged(this, e);
        }
        protected override CreateParams CreateParams {
            get {
                if(!initialized) {
                    InitCommonControlsEX ic = new InitCommonControlsEX();
                    ic.Size = Marshal.SizeOf(typeof(InitCommonControlsEX));
                    ic.Icc = ICC_INTERNET_CLASSES;
                    initialized = InitCommonControlsEx(ref ic);
                }
                if(initialized) {
                    CreateParams cp = base.CreateParams;
                    cp.ClassName = "SysIPAddress32";
                    cp.Height = 23;
                    cp.ClassStyle = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS | CS_GLOBALCLASS;
                    cp.Style = WS_CHILD | WS_VISIBLE | WS_TABSTOP | 0x80;
                    cp.ExStyle = WS_EX_NOPARENTNOTIFY | WS_EX_CLIENTEDGE;
                    if(RightToLeft == RightToLeft.No || 
                      (RightToLeft == RightToLeft.Inherit && 
                       Parent.RightToLeft == RightToLeft.No )) {
                        cp.ExStyle |= WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
                    } else {
                        cp.ExStyle |= WS_EX_RIGHT | WS_EX_RTLREADING | WS_EX_LEFTSCROLLBAR;
                    }
                    return cp;
                } else {
                    return base.CreateParams;
                }
            }
        }
        public bool SetIPRange(IPField field, byte lowValue, byte highValue) {
            if(!initialized) return false;		
            Message m = Message.Create(
                                  Handle, 
                                  IPM_SETRANGE, 
                                  (IntPtr)((int)field), 
                                  MakeRange(lowValue, highValue));
            WndProc(ref m);
            return m.Result.ToInt32() > 0;
        }
        public System.Net.IPAddress IPAddress {
            get {
                if(!initialized) return IPAddress.None;			
                return IPAddress.Parse(base.Text);
            }
        }
        public bool IsBlank {
            get {
                if(!initialized) return !(base.Text.Length > 0);
                Message m = Message.Create(Handle, IPM_ISBLANK, IntPtr.Zero, IntPtr.Zero);
                WndProc(ref m);
                return m.Result.ToInt32() > 0;
            }
        }
        new public void Clear() {
            if(!initialized) {
                base.Clear();
                return;
            }		
            Message m = Message.Create(Handle, IPM_CLEARADDRESS, IntPtr.Zero, IntPtr.Zero);
            WndProc(ref m);
        }
        private System.Net.IPAddress GetIpAddress(IntPtr ip) {
            if(!initialized) return IPAddress.None;		
            return new IPAddress(ip.ToInt64());
        }
        private IntPtr MakeRange(byte low, byte high) {
            return (IntPtr)((int)((high << 8) + low));
        }
        protected override void WndProc(ref Message m) {
            if(m.Msg == (WM_REFLECT + WM_NOTIFY)) {
                NmIPAddress ipInfo = (NmIPAddress)Marshal.PtrToStructure(m.LParam,
                                                                   typeof(NmIPAddress));
                if(ipInfo.Hdr.Code == IPN_FIRST) {
                    if(values[ipInfo.Field] != ipInfo.Value) {
                        values[ipInfo.Field] = ipInfo.Value;
                        OnFieldChanged(
                          new FieldChangedEventArgs(ipInfo.Field, ipInfo.Value));
                    }
                }
            }
            base.WndProc(ref m);
        }
    }
}
C#

It does have one wrapped event from the original control and that is FieldChanged, which provides feedback when each octet is changed (similar to TextChanged for a text box, but only fires after the user has entered the entire text for an octet). Likewise, if the value of an octet is larger than a byte, it is automatically changed back to 255 (i.e., the max value of a byte). When the event fires, it passes back, the octet that was changed, and its value.

You can specify the IP Range (which the original control allows, and I’ve wrapped into this control as well) so that you can edit the control to only accept a specified IP Address Range.

I’ve also provided Native Clear functionality as well as the IsBlank from the original control. I added a System.Net.IPAddress property so that when accessing the IPAddress of the control, you didn’t need to parse the System.Net.IPAddress every time. My original control completely removed the Text property so that you get / set the IPAddress through this property, but alas, that functionality doesn’t exist in this control.

UPDATE: 8/25/2006 – I Made two changes to the source code, 1. added some Initialization logic to keep InitCommonCtrls from being called multiple times and, 2. added styles for ClassStyle, StyleEX and Style to keep an exception from being thrown in certain cases when the WM_GETTEXTLENGTH message was sent.

]]> A Simple Line Control http://www.sanity-free.com/simple_line_control.html Sun, 29 May 2005 18:00:15 +0000 http://dev.sanity-free.org/?p=45 Some time ago, I was working on a clone of Solitaire (the one that comes with windows), and I needed a line control (for… surprise surprise… the about box) like the one shown in its about window:

Example Line Control
Example Line Control

after a brisk 2 seconds I came up with the following class:

/******************************************************/
/*          NULLFX FREE SOFTWARE LICENSE              */
/******************************************************/
/*  Line Control                                      */
/*  by: Steve Whitley                                 */
/*  © 2005 NullFX Software                            */
/*                                                    */
/* NULLFX SOFTWARE DISCLAIMS ALL WARRANTIES,          */
/* RESPONSIBILITIES, AND LIABILITIES ASSOCIATED WITH  */
/* USE OF THIS CODE IN ANY WAY, SHAPE, OR FORM        */
/* REGARDLESS HOW IMPLICIT, EXPLICIT, OR OBSCURE IT   */
/* IS. IF THERE IS ANYTHING QUESTIONABLE WITH REGARDS */
/* TO THIS SOFTWARE BREAKING AND YOU GAIN A LOSS OF   */
/* ANY NATURE, WE ARE NOT THE RESPONSIBLE PARTY. USE  */
/* OF THIS SOFTWARE CREATES ACCEPTANCE OF THESE TERMS */
/*                                                    */
/* USE OF THIS CODE MUST RETAIN ALL COPYRIGHT NOTICES */
/* AND LICENSES (MEANING THIS TEXT).                  */
/*                                                    */
/******************************************************/

namespace NullFX.Controls {
    using System;
    using System.Collections;
    using System.ComponentModel;
    using System.Drawing;
    using System.Data;
    using System.Windows.Forms;
    using System.Windows.Forms.Design;
    [Designer(typeof(Line.LineDesigner))]
    public class Line : Control {
        internal class LineDesigner : ControlDesigner {
            public override SelectionRules SelectionRules {
                get {
                    return SelectionRules.LeftSizeable |
                        SelectionRules.RightSizeable |
                        SelectionRules.Visible |
                        SelectionRules.Moveable;
                }
            }

        }
        private FlatStyle _flatStyle;
        private Pen _systemPen;
        private Container components = null;
        [Category("Appearance"), 
        Description(
        "Determines the display of the control" +
        "when the users move the mouse over the control" +
        "and click")]
        public FlatStyle FlatStyle {
            get{return _flatStyle;}
            set{
                _flatStyle = value;
                Invalidate();
            }
        }
        public Line() {
            _flatStyle = FlatStyle.Standard;
            _systemPen = 
                  new Pen(SystemColors.ControlDark, 2);
            SetStyle(ControlStyles.AllPaintingInWmPaint |
                ControlStyles.DoubleBuffer|
                ControlStyles.ResizeRedraw|
                ControlStyles.UserPaint, true);
        }		 
        protected override void Dispose( bool disposing ) {
            if( disposing ) {
                if( components != null ) {
                    components.Dispose();
                }
            }
            base.Dispose( disposing );
        }
        protected override Size DefaultSize {
            get {
                return new System.Drawing.Size(120, 2);
            }
        } 
        protected override void OnPaint(PaintEventArgs pe) {
            switch(_flatStyle) { 
                case FlatStyle.Flat:
                case FlatStyle.Popup:
                case FlatStyle.Standard: {
                    pe.Graphics.FillRectangle(
                       SystemBrushes.ControlLightLight, 
                       0, 0, Width, 2);
                    pe.Graphics.FillRectangle(
                       SystemBrushes.ControlDark, 
                       0, 0, Width - 1, Height / 2); 
                }break;
                case System.Windows.Forms.FlatStyle.System: {
                    pe.Graphics.DrawLine(_systemPen, 
                                             0, 1, Width, 1);
                }break;
                default:
                    goto case FlatStyle.Standard; 
            }
        }
    }
}
C#

Now to talk over a few points in this very simple control.

There were 2 requirements I had for the control:

  1. It had to have an inherent size when I dragged it onto the canvass
  2. it had to keep its aspect ratio (meaning I couldn’t make it look inconsistent)

I was able to accomplish this using a class designer, and by overriding the DefaultSize property of the control. I could have gotten much more fancy with the control, but since I was going to be the only one using it (well… that was the plan anyway :D), I kept it super simple.

protected override Size DefaultSize {
    get {
        return new System.Drawing.Size(120, 2);
    }
}
C#

This allows the control to default to this size. Anytime the control needs its base size, it uses the DefaultSize property. My first iteration of this control actually set the size property in the InitializeComponent method, but after reading up on it, using the DefaultSize property and specifying its size is the better solution.

The next thing was to keep its aspect ratio. This is achieved by providing my control with a designer. There are lots of articles out there on how to implement a designer, so I’ll leave that for another topic, and just discuss what I used in the designer to accomplish this.
There is a property in the ControlDesigner called SelectionRules. This tells the control host at design time, how it can be used. Here’s our designer class. It’s actually an inner class of the Line control.

internal class LineDesigner : ControlDesigner {
	public override SelectionRules SelectionRules {
		get {
			return SelectionRules.LeftSizeable |
				SelectionRules.RightSizeable |
				SelectionRules.Visible |
				SelectionRules.Moveable;
		}
	}
}
C#

Notice we’re only overriding the SelectionRules property. It returns a bit flag value of which types of selection are possible in the designer. I didn’t want the control to be sized up or down, so I left those selection rules out. I did want it to be able to be sized right or left, and movable (and obviously visible), so these are the rules I return.

Other than this, all we need is to draw the line. This is achieved by overriding the OnPaint function in the control. I have provided functionality (however ugly it may be) for flat style, but for simplicity, I’ll speak to the normal line.
The line in the about box has a highlight line and a shadow line. In our OnPaint method, I draw both lines using Control.Dark and Control.LightLight colors (this is so these colors can match whatever theme is being used).

case FlatStyle.Standard: {
	pe.Graphics.FillRectangle( SystemBrushes.ControlLightLight, 0, 0, Width, 2 );
	pe.Graphics.FillRectangle( SystemBrushes.ControlDark, 0, 0, Width - 1, Height / 2 );
}break;
C#

Anyway, this is my simple line control.

Download the Binary Here.

]]> Numeric Text Box: A Number Only Text Box Control in C# http://www.sanity-free.com/numeric_text_box_number_only_text_box_control_in_csharp.html Thu, 14 Apr 2005 18:00:57 +0000 http://dev.sanity-free.org/?p=32 Here’s my numeric only text control. I’ll admit there’s not much too it, and there are masked edit controls, but for those who dare…

/******************************************************/
/*          NULLFX FREE SOFTWARE LICENSE              */
/******************************************************/
/*  NumericTextBox Library                            */
/*  by: Steve Whitley                                 */
/*  © 2005 NullFX Software                            */
/*                                                    */
/* NULLFX SOFTWARE DISCLAIMS ALL WARRANTIES,          */
/* RESPONSIBILITIES, AND LIABILITIES ASSOCIATED WITH  */
/* USE OF THIS CODE IN ANY WAY, SHAPE, OR FORM        */
/* REGARDLESS HOW IMPLICIT, EXPLICIT, OR OBSCURE IT   */
/* IS. IF THERE IS ANYTHING QUESTIONABLE WITH REGARDS */
/* TO THIS SOFTWARE BREAKING AND YOU GAIN A LOSS OF   */
/* ANY NATURE, WE ARE NOT THE RESPONSIBLE PARTY. USE  */
/* OF THIS SOFTWARE CREATES ACCEPTANCE OF THESE TERMS */
/*                                                    */
/* USE OF THIS CODE MUST RETAIN ALL COPYRIGHT NOTICES */
/* AND LICENSES (MEANING THIS TEXT).                  */
/*                                                    */
/******************************************************/

namespace NullFX.Controls {
    using System;
    using System.Collections.Generic;
    using System.Globalization;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Windows.Forms;

    public class NumericTextBox : TextBox {
        static NumberFormatInfo CurrentNumberFormat = 
               CultureInfo.CurrentCulture.NumberFormat;
        const int WM_KEYDOWN = 0x0100,
                  WM_PASTE = 0x0302;

        public decimal Value {
            set { Text = value.ToString ( ); }
            get {
                decimal.TryParse ( Text, out decimal tmpValue );
                return tmpValue;
            }
        }

        public override bool PreProcessMessage ( ref Message msg ) {
            if ( msg.Msg == WM_KEYDOWN ) {
                Keys keys = ( Keys ) msg.WParam.ToInt32 ( );
                bool isPaste = keys == Keys.V && ModifierKeys == Keys.Control;
                bool isNumeric = IsNumeric ( keys );
                bool isKeyValid = IsKeyValid ( keys );
                if ( isNumeric | isKeyValid ) {
                    return false;
                } else if ( isPaste ) {
                    IDataObject obj = Clipboard.GetDataObject ( );
                    string input = ( string ) obj.GetData ( typeof ( string ) );
                    if ( !IsInputOrTextNumeric ( input ) ) {
                        return true;
                    }
                    return false;
                } else {
                    return true;
                }
            } else {
                return base.PreProcessMessage ( ref msg );
            }
        }

        protected override void WndProc ( ref Message m ) {
            if ( m.Msg == WM_PASTE ) {
                IDataObject obj = Clipboard.GetDataObject ( );
                string input = ( string ) obj.GetData ( typeof ( string ) );
                if ( !IsInputOrTextNumeric ( input ) ) {
                    m.Result = ( IntPtr ) 0;
                    return;
                }

            }
            base.WndProc ( ref m );
        }

        private bool IsNumeric ( Keys key ) {
            return ( ( key >= Keys.D0 && key <= Keys.D9 ) ||
                   ( key >= Keys.NumPad0 && key <= Keys.NumPad9 ) ) &&
                   ModifierKeys != Keys.Shift;
        }

        private bool IsKeyValid ( Keys key ) {
            bool ctrl = key == Keys.Control;
            bool ctrlZ = key == Keys.Z && ModifierKeys == Keys.Control,
                 ctrlX = key == Keys.X && ModifierKeys == Keys.Control,
                 ctrlC = key == Keys.C && ModifierKeys == Keys.Control,
                 ctrlV = key == Keys.V && ModifierKeys == Keys.Control,
                 homeEnd = key == Keys.Home | key == Keys.End,
                 del = key == Keys.Delete,
                 bksp = key == Keys.Back,
                 arrows = ( key == Keys.Up ) | ( key == Keys.Down ) | 
                          ( key == Keys.Left ) | ( key == Keys.Right );
            bool standardTests = ctrl | del | bksp | arrows | homeEnd | 
                                 ctrlC | ctrlX | ctrlV | ctrlZ;
            bool containsTokenChar = false;
            if ( !standardTests ) {
                string token = VKtoChar ( key );
                containsTokenChar = validTokens.ContainsKey ( token );
                if ( token != CurrentNumberFormat.CurrencyGroupSeparator && 
                    Text.Contains ( token ) ) {
                    containsTokenChar = false;
                }
                if ( !IsInputOrTextNumeric ( token ) ) {
                    containsTokenChar = false;
                }
            }
            return standardTests | containsTokenChar;
        }

        private bool IsInputOrTextNumeric ( string tokenOrInput ) {
            string tmp = Text;
            string inserted = tmp.Insert ( SelectionStart, tokenOrInput );
            if ( !decimal.TryParse ( inserted, out decimal result ) ) {
                return false;
            }
            return true;
        }

        private static string VKtoChar ( Keys key ) {
            StringBuilder sb = new StringBuilder ( 256 );
            byte[] keystate = new byte[256];
            if ( GetKeyboardState ( keystate ) ) {
                uint scanCode = MapVirtualKey ( ( uint ) key, 2 );
                int res = ToUnicode ( ( uint ) key, scanCode, keystate, sb, 256, 2 );
            }
            return sb.ToString ( );
        }

        static Dictionary<string, string> validTokens = 
                                      new Dictionary<string, string> ( );

        static NumericTextBox ( ) {
            validTokens.Add ( CurrentNumberFormat.NegativeSign, "" );
            validTokens.Add ( CurrentNumberFormat.NumberDecimalSeparator, "" );
            validTokens.Add ( CurrentNumberFormat.CurrencyGroupSeparator, "" );
        }

        [DllImport ( "user32.dll", SetLastError = true )]
        private static extern bool GetKeyboardState ( byte[] receivingBuffer );

        [DllImport ( "user32.dll", SetLastError = true )]
        private static extern int ToUnicode ( uint virtualKey, uint scanCode, 
            byte[] keyState, [Out, MarshalAs ( UnmanagedType.LPWStr, SizeConst = 256 )]  
            StringBuilder buffer, int bufferSize, uint flags );
        [DllImport ( "user32.dll" )]
        private static extern uint MapVirtualKey ( uint keyCode, uint mapType );
    }
}
C#

What this does, is watch the Windows Message Queue for incoming messages (specifically WM_KEYDOWN and WM_PASTE). If a key has been pressed, it will look to see if the key is actually a number. It also looks to see if a paste command has been sent. if a key has been pressed and it is a numeric key (there are a few more keys for convenience sake) or the paste operation has been invoked (the contents of the paste operation are checked to make sure that anything that gets pasted is a number, else it fails to paste in the data) and its contents are numeric, allows that data to be pasted into the textbox.

Since originally posting this control on my older website, I’ve made some minor updates, checking the key pressed against its text character, checking to see if the resulting value will parse as a decimal and adding a few more keystroke character checks in there.

For Clarity sake, PreProcessMessage is invoked before the Message is sent into the message queue. If the control handles this message, it returns true, and the message ends there. If it returns false, it will send the Message into the message pump for further processing. WndProc is similar to WindowProc in win32, and one can filter messages sent here like they used to in standard windows programming. In this sample, we’re peeking at the KEYDOWN message, in the PreProcessMessage function. Commands are not sent through here, but are passed in WndProc, where we can listen, and handle this Message ourselves (because we need to check the contents of the clip board for numeric data).

If PreProcessMessage‘s Message contains numeric or one of our allowed keys, it returns false which forces the base TextBox to handle the instruction like normal, if not it returns true meaning we’ve handled it and it doesn’t get passed into the base TextBox control and nothing flows to the textbox. If WndProc receives a numeric only string in the clip board, then it sends the message to the base TextBox

base.WndProc(ref m);

if the clipboard contains alpha or other data, it sets the LResult to 0, and returns without passing the message to the base TextBox effectively saying we’ve handled the message, and there’s no need to process it any further.

]]> ScrollableRichTextBox http://www.sanity-free.com/scrollablerichtextbox.html Mon, 19 Apr 2004 18:00:24 +0000 http://dev.sanity-free.org/?p=26 The standard RichTextBox’s “Auto-Scroll” functionality is so obscure, that most rarely ever find out how to use it. This class appends text and gives the option for the user to scroll to the bottom of the textbox.

/******************************************************/
/*          NULLFX FREE SOFTWARE LICENSE              */
/******************************************************/
/*  ScrollableRichTextBox Library                     */
/*  by: Steve Whitley                                 */
/*  © 2005 NullFX Software                            */
/*                                                    */
/* NULLFX SOFTWARE DISCLAIMS ALL WARRANTIES,          */
/* RESPONSIBILITIES, AND LIABILITIES ASSOCIATED WITH  */
/* USE OF THIS CODE IN ANY WAY, SHAPE, OR FORM        */
/* REGARDLESS HOW IMPLICIT, EXPLICIT, OR OBSCURE IT   */
/* IS. IF THERE IS ANYTHING QUESTIONABLE WITH REGARDS */
/* TO THIS SOFTWARE BREAKING AND YOU GAIN A LOSS OF   */
/* ANY NATURE, WE ARE NOT THE RESPONSIBLE PARTY. USE  */
/* OF THIS SOFTWARE CREATES ACCEPTANCE OF THESE TERMS */
/*                                                    */
/* USE OF THIS CODE MUST RETAIN ALL COPYRIGHT NOTICES */
/* AND LICENSES (MEANING THIS TEXT).                  */
/*                                                    */
/******************************************************/

namespace NullFX.Controls {
    using System;
    using System.Windows.Forms;
    /// <summary>
    /// This components adds a much lacking function
    /// "Scroll to the end" which is missing
    /// from the original rich text box.
    /// </summary>
    public class ScrollableRichTextBox : RichTextBox {
        // constants for the message sending
        const int WM_VSCROLL = 0x0115;
        const int WM_LBUTTONDOWN = 0x0201;
        const int WM_SETFOCUS = 0x0007;
        const int WM_KILLFOCUS = 0x0008;
        readonly IntPtr SB_ENDSCROLL = (IntPtr)8;
        readonly IntPtr SB_BOTTOM = (IntPtr)7;
        // flag we use to determine if we can scroll
        bool _scrollable = true;
        private delegate void AppendTextDelegate(string text, bool scrollToEnd);
        public void AppendText(string text, bool scrollToEnd) {
            if(InvokeRequired) {
                Invoke(new AppendTextDelegate(AppendText), 
                           new object[] {text, scrollToEnd});
            }else {
                decimal length = base.Text.Length + text.Length;
                if(length >= base.MaxLength) base.Clear();
                base.Text += text;
                if(_scrollable && scrollToEnd) {
                    if(IntPtr.Zero != base.Handle) {
                        base.SelectionStart = base.Text.Length;
                        Message m = Message.Create(
                            base.Handle, 
                            WM_VSCROLL, 
                            SB_BOTTOM, IntPtr.Zero);
                        base.WndProc(ref m);
                    }
                }
            }

        }

        protected override void WndProc(ref Message m) {
            // if we're in a scroll set the scrolling flag 
            // to false & skip theauto scroll
            if((m.Msg == WM_LBUTTONDOWN) 
                || m.Msg == WM_VSCROLL 
                && m.WParam != SB_BOTTOM) {
                _scrollable = false;
            }

            // if we are done scrolling, set the falg to true & do the scrolling
            if(m.Msg == WM_VSCROLL && m.WParam == SB_ENDSCROLL) {
                _scrollable = true;
            }
            // HACK: this keeps the user from setting the cursor in the textbox
            //  because that causes problems if they do
            if(m.Msg == WM_SETFOCUS && base.ReadOnly) m.Msg = WM_KILLFOCUS;

            base.WndProc (ref m);
        }
    }
}
C#

There used to be a threading problem which would throw an unhandled exception every now and then, but due to an article recently published on msdn blogs this has been fixed, and the change is reflected above.

]]>