Pete's Weblog

Automatic Windows Update

Pete Vidler — Fri, 24 Sep 2004 16:47:00 GMT

Looks like my computer is doing a windows update. I didn't ask it to (I don't have automatic updates turned on), but I guess this is WinXP SP2 installing itself. I'm a bit pissed off that it didn't even tell me it was going to install something -- it just appeared as an icon in the notification area.

If it suddenly pops up a dialog asking me to reset the computer (or worse, does it for me without asking), I'll be going back to Linux. Imagine getting a sudden popup asking you to reset your computer; if you didn't notice the thing installing, an inexperienced user will probably think it was a virus like blaster. The question is, would they be wrong?

Update:

The mysterious update appears to have stopped downloading at 47%. There is no internet activity. There appears to be no way to cancel or restart the download (no context menu, nothing happens when I double-click it). I will have to wait a while then try to end the process, I guess. How is an ordinary, non-technical user supposed to deal with this?

Second Update:

Okay, I ended the process. The icon disappeared and then immediately reappeared. That's cheating! On the plus side, it now seems to be at 48% (and it's only been two hours to get that extra 1%).

What is really getting on my nerves is that I'm moving tomorrow. This computer probably won't touch the internet again for a long time (possibly years, as I will be using computers at uni). I really needed to spend this time downloading the programs and websites that I will need so they can be used offline, and not worrying about whether this weird update will go away or not.

Extending RichTextBox - Part III

Pete Vidler — Thu, 16 Oct 2003 00:33:00 GMT

As promised earlier, I've added the ability to change the background colour of the text. I've also made one or two minor changes to the rest of the code, which I'll detail at the end.

Background Colour

Changing the background colour is a simple matter. It works in exactly the same way as changing the underline style, by setting the character format. Since we're dealing with Color here, we need to be using System.Drawing. Then it's just a matter of sending the correct message:

+ Code to set the background colour for a selected region.

/// <summary>
/// Gets or sets the background color to apply to the
/// current selection or insertion point.
/// </summary>
/// <remarks>
/// If the selection contains more than one background
/// color, then this property will indicate it by
/// returning Color.Empty.
/// </remarks>
public Color SelectionBackColor
{
    get
    {
        CHARFORMAT fmt = new CHARFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        
        // Get the background color.
        SendMessage( new HandleRef( this, Handle ), EM_GETCHARFORMAT,
                     SCF_SELECTION, ref fmt );
        
        // Default to Color.Empty as there could be
        // several colors present in this selection.
        if ( ( fmt.dwMask & CFM_BACKCOLOR ) == 0 )
            return Color.Empty;
        
        // Deal with the weird Windows color format.
        int backCol = fmt.crBackColor;
        Color ret = ColorTranslator.FromWin32( backCol );
        
        return ret;
    }
    
    set
    {
        CHARFORMAT fmt = new CHARFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        fmt.dwMask = CFM_BACKCOLOR;
        
        // Deal with the weird Windows color format.
        fmt.crBackColor = ColorTranslator.ToWin32( value );
        
        // Set the background color.
        SendMessage( new HandleRef( this, Handle ), EM_SETCHARFORMAT,
                     SCF_SELECTION, ref fmt );
    }
}

And there's one more constant to add:

private const int CFM_BACKCOLOR = 67108864;

That should now enable us to change the background colour of the text. Simple, wasn't it?

Alterations

Notice in the middle of the get method above, we return Color.Empty by default. This is because that return value is used when more than one colour is selected (like in Word when you select across several fonts and the font selection combobox goes blank). A similar approach can be taken in the alignment and underline properties presented previously.

All you have to do is add an entry to the relevant enumeration called "None" (or whatever), probably equal to zero, and return it in the appropriate get method where it says "Default to <whatever>".

Conclusion

That's it for AdvRichTextBox. If anyone is actually reading this and wants me to add more functionality (or post complete source), just leave a comment or send me an email.

Extending RichTextBox - Part II

Pete Vidler — Wed, 15 Oct 2003 14:19:00 GMT

Microsoft Word and Visual Studio have one very cool feature in common -- squiggly underlining of errors. As of richedit 3.0 (distributed with Windows 2000 and higher, possibly also with ME) we can get these in the RichTextBox. Actually, we can get a lot more underline styles than that...

Underlining

Once again we are going to have to communicate with the underlying richedit control. This time we need to set the character format, so we'll need to add some extra stuff to our class:

+ Code to interface with the Win32 CHARFORMAT2 structure.

private const int CFM_UNDERLINETYPE = 8388608;
private const int EM_SETCHARFORMAT = 1092;
private const int EM_GETCHARFORMAT = 1082;

[StructLayout( LayoutKind.Sequential )]
private struct CHARFORMAT
{
    public int cbSize;
    public uint dwMask;
    public uint dwEffects;
    public int yHeight;
    public int yOffset;
    public int 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 int crBackColor;
    public int LCID;
    public uint dwReserved;
    public short sStyle;
    public short wKerning;
    public byte bUnderlineType;
    public byte bAnimation;
    public byte bRevAuthor;
}

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

Underline Style

The underline style and colour are both set with the same message, so we must be careful to preserve the colour while changing the underline style. We'll use a property again so that we remain consistent with the original RichTextBox:

+ Code to set the underline style.

/// <summary>
/// Gets or sets the underline style to apply to the
/// current selection or insertion point.
/// </summary>
/// <remarks>
/// Underline styles can be set to any value of the
/// <see cref="UnderlineStyle"/> enumeration.
/// </remarks>
public UnderlineStyle SelectionUnderlineStyle
{
    get
    {
        CHARFORMAT fmt = new CHARFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        
        // Get the underline style.
        SendMessage( new HandleRef( this, Handle ), EM_GETCHARFORMAT,
                     SCF_SELECTION, ref fmt );
        
        // Default to no underline.
        if ( ( fmt.dwMask & CFM_UNDERLINETYPE ) == 0 )
            return UnderlineStyle.None;
        
        byte style = ( byte )( fmt.bUnderlineType & 0x0F );
        
        return ( UnderlineStyle )style;
    }
    
    set
    {
        // Ensure we don't alter the color by accident.
        UnderlineColor color = SelectionUnderlineColor;
        
        // Ensure we don't show it if it shouldn't be shown.
        if ( value == UnderlineStyle.None )
            color = UnderlineColor.Black;
        
        CHARFORMAT fmt = new CHARFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        fmt.dwMask = CFM_UNDERLINETYPE;
        fmt.bUnderlineType = ( byte )( ( byte )value | ( byte )color );
        
        // Set the underline type.
        SendMessage( new HandleRef( this, Handle ), EM_SETCHARFORMAT,
                     SCF_SELECTION, ref fmt );
    }
}

Once again, this has not been fully tested so you use it at your own risk. Let me know if there are any problems, etc. The UnderlineStyle enumeration is also fairly straightforward:

+ UnderlineStyle enumeration.

/// <summary>
/// Specifies the style of underline that should be
/// applied to the text.
/// </summary>
public enum UnderlineStyle
{
    /// <summary>
    /// No underlining.
    /// </summary>
    None = 0,
    
    /// <summary>
    /// Standard underlining across all words.
    /// </summary>
    Normal = 1,
    
    /// <summary>
    /// Standard underlining broken between words.
    /// </summary>
    Word = 2,
    
    /// <summary>
    /// Double line underlining.
    /// </summary>
    Double = 3,
    
    /// <summary>
    /// Dotted underlining.
    /// </summary>
    Dotted = 4,
    
    /// <summary>
    /// Dashed underlining.
    /// </summary>
    Dash = 5,
    
    /// <summary>
    /// Dash-dot ("-.-.") underlining.
    /// </summary>
    DashDot = 6,
    
    /// <summary>
    /// Dash-dot-dot ("-..-..") underlining.
    /// </summary>
    DashDotDot = 7,
    
    /// <summary>
    /// Wave underlining (like spelling mistakes in MS Word).
    /// </summary>
    Wave = 8,
    
    /// <summary>
    /// Extra thick standard underlining.
    /// </summary>
    Thick = 9,
    
    /// <summary>
    /// Extra thin standard underlining.
    /// </summary>
    HairLine = 10,
    
    /// <summary>
    /// Double thickness wave underlining.
    /// </summary>
    DoubleWave = 11,
    
    /// <summary>
    /// Thick wave underlining.
    /// </summary>
    HeavyWave = 12,
    
    /// <summary>
    /// Extra long dash underlining.
    /// </summary>
    LongDash = 13
}

Note that some of these styles may not display correctly. This is a common problem with the richedit control, often you will apply some formatting only to find that it will not display at all. The formatting is usually stored though, so cutting and pasting into Word will show the text correctly.

Underline Colour

We can also change the underline colour. Notice how the set method of underline colour retrieves the underline style in order to maintain consistency.

+ Code to set the underline colour.

/// <summary>
/// Gets or sets the underline color to apply to the
/// current selection or insertion point.
/// </summary>
/// <remarks>
/// Underline colors can be set to any value of the
/// <see cref="UnderlineColor"/> enumeration.
/// </remarks>
public UnderlineColor SelectionUnderlineColor
{
    get
    {
        CHARFORMAT fmt = new CHARFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        
        // Get the underline color.
        SendMessage( new HandleRef( this, Handle ), EM_GETCHARFORMAT,
                     SCF_SELECTION, ref fmt );
        
        // Default to black.
        if ( ( fmt.dwMask & CFM_UNDERLINETYPE ) == 0 )
            return UnderlineColor.Black;
        
        byte style = ( byte )( fmt.bUnderlineType & 0xF0 );
        
        return ( UnderlineColor )style;
    }
    
    set
    {
        // Ensure we don't alter the style.
        UnderlineStyle style = SelectionUnderlineStyle;
        
        // Ensure we don't show it if it shouldn't be shown.
        if ( style == UnderlineStyle.None )
            value = UnderlineColor.Black;
        
        CHARFORMAT fmt = new CHARFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        fmt.dwMask = CFM_UNDERLINETYPE;
        fmt.bUnderlineType = ( byte )( ( byte )style | ( byte )value );
        
        // Set the underline color.
        SendMessage( new HandleRef( this, Handle ), EM_SETCHARFORMAT,
                     SCF_SELECTION, ref fmt );
    }
}

Unfortunately there are not many colours available to this property. They are defined by the UnderlineColor enumeration:

+ UnderlineColor enumeration.

/// <summary>
/// Specifies the color of underline that should be
/// applied to the text.
/// </summary>
/// <remarks>
/// I named these colors by their appearance, so some
/// of them might not be what you expect. Please email
/// me if you feel one should be changed.
/// </remarks>
public enum UnderlineColor
{
    /// <summary>Black.</summary>
    Black = 0x00,
    
    /// <summary>Blue.</summary>
    Blue = 0x10,
    
    /// <summary>Cyan.</summary>
    Cyan = 0x20,
    
    /// <summary>Lime green.</summary>
    LimeGreen = 0x30,
    
    /// <summary>Magenta.</summary>
    Magenta = 0x40,
    
    /// <summary>Red.</summary>
    Red = 0x50,
    
    /// <summary>Yellow.</summary>
    Yellow = 0x60,
    
    /// <summary>White.</summary>
    White = 0x70,
    
    /// <summary>DarkBlue.</summary>
    DarkBlue = 0x80,
    
    /// <summary>DarkCyan.</summary>
    DarkCyan = 0x90,
    
    /// <summary>Green.</summary>
    Green = 0xA0,
    
    /// <summary>Dark magenta.</summary>
    DarkMagenta = 0xB0,
    
    /// <summary>Brown.</summary>
    Brown = 0xC0,
    
    /// <summary>Olive green.</summary>
    OliveGreen = 0xD0,
    
    /// <summary>Dark gray.</summary>
    DarkGray = 0xE0,
    
    /// <summary>Gray.</summary>
    Gray = 0xF0
}

If you set the underline colour to anything other than black it will not serialise correctly. I don't know if this is by design or not. Any text with a non-black underline that is cut and pasted into Word (or any other application) will lose it's underlining all together. I don't know if the underline is still stored in the actual rich text or not when this happens.

Conclusion

Well that's it for part two. In my next post in this series I will cover setting the background colour.

Extending RichTextBox

Pete Vidler — Tue, 14 Oct 2003 22:02:00 GMT

For a while now I've been toying with the idea of writing a C# editor (almost an IDE, but with only the features that I need). Clearly the hardest part of this task would be getting some form of edit control working.. the obvious choice for which is the RichTextBox. Anyone who has tried using RichTextBox in this situation will know that it has a number of flaws, the most serious being that it's rather slow when trying to colourise the text.

I've long since given up on using RichTextBox for a code editor, but while I was investigating its use I came across a number of ways to improve it's functionality. I'll present these here in a series of posts on the subject.. first up is how to speed up the control's updating, as well as adding one little extra formatting option.

Faster Updating

There are articles on this subject on the internet. The standard method seems to be to send a WM_SETREDRAW message to prevent the control from being redrawn while updating. I had this implemented and running nicely when I came across another article showing that an extra speed increase can be gained by sending EM_SETEVENTMASK to prevent the control from handling events. Here's the code:

+ Code to help speed up RichTextBox updating.

/// <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 );
}

Although I'm using HandleRef here, I have absolutely no idea if this is the correct usage (or even if it's needed). Full code will be at the end of this posting. I have not fully tested these methods so I have no idea what the performance gains might be (if there are any). If anyone wants to try benchmarking, please let me know the results.

Justification

It always bothered me that the SelectionAlignment property of RichTextBox does not allow fully justified text. Especially since I know it's possible with the richedit control that RichTextBox wraps. Here's some code that will replace SelectionAlignment with something a little nicer for those that are writing word processors in C#:

+ Code to allow justified text in the RichTextBox.

/// <summary>
/// Gets or sets the alignment to apply to the current
/// selection or insertion point.
/// </summary>
/// <remarks>
/// Replaces the SelectionAlignment from
/// <see cref="RichTextBox"/>.
/// </remarks>
public new TextAlign SelectionAlignment
{
    get
    {
        PARAFORMAT fmt = new PARAFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        
        // Get the alignment.
        SendMessage( new HandleRef( this, Handle ),
                     EM_GETPARAFORMAT,
                     SCF_SELECTION, ref fmt );
        
        // Default to Left align.
        if ( ( fmt.dwMask & PFM_ALIGNMENT ) == 0 )
            return TextAlign.Left;
        
        return ( TextAlign )fmt.wAlignment;
    }
    
    set
    {
        PARAFORMAT fmt = new PARAFORMAT();
        fmt.cbSize = Marshal.SizeOf( fmt );
        fmt.dwMask = PFM_ALIGNMENT;
        fmt.wAlignment = ( short )value;
        
        // Set the alignment.
        SendMessage( new HandleRef( this, Handle ),
                     EM_SETPARAFORMAT,
                     SCF_SELECTION, ref fmt );
    }
}

The TextAlign enumeration contains Left, Right, Center and Justify. Again, this is mostly untested -- it should work on any machine with the richedit 2.0 common control (I believe), but I offer no guarantees.

Code

Here's the full code for the AdvRichTextBox control (plus the TextAlign enumeration):

+ Full AdvRichTextBox code.

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;

/// <summary>
/// Represents a standard <see cref="RichTextBox"/> with some
/// minor added functionality.
/// </summary>
/// <remarks>
/// AdvRichTextBox provides methods to maintain performance
/// while it is being updated. Additional formatting features
/// have also been added.
/// </remarks>
public class AdvRichTextBox : RichTextBox
{
    /// <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>
    /// Gets or sets the alignment to apply to the current
    /// selection or insertion point.
    /// </summary>
    /// <remarks>
    /// Replaces the SelectionAlignment from
    /// <see cref="RichTextBox"/>.
    /// </remarks>
    public new TextAlign SelectionAlignment
    {
        get
        {
            PARAFORMAT fmt = new PARAFORMAT();
            fmt.cbSize = Marshal.SizeOf( fmt );
            
            // Get the alignment.
            SendMessage( new HandleRef( this, Handle ),
                         EM_GETPARAFORMAT,
                         SCF_SELECTION, ref fmt );
            
            // Default to Left align.
            if ( ( fmt.dwMask & PFM_ALIGNMENT ) == 0 )
                return TextAlign.Left;
            
            return ( TextAlign )fmt.wAlignment;
        }
        
        set
        {
            PARAFORMAT fmt = new PARAFORMAT();
            fmt.cbSize = Marshal.SizeOf( fmt );
            fmt.dwMask = PFM_ALIGNMENT;
            fmt.wAlignment = ( short )value;
            
            // Set the alignment.
            SendMessage( new HandleRef( this, Handle ),
                         EM_SETPARAFORMAT,
                         SCF_SELECTION, ref fmt );
        }
    }
    
    /// <summary>
    /// This member overrides
    /// <see cref="Control"/>.OnHandleCreated.
    /// </summary>
    protected override void OnHandleCreated( EventArgs e )
    {
        base.OnHandleCreated( e );
        
        // Enable support for justification.
        SendMessage( new HandleRef( this, Handle ),
                     EM_SETTYPOGRAPHYOPTIONS,
                     TO_ADVANCEDTYPOGRAPHY,
                     TO_ADVANCEDTYPOGRAPHY );
    }
    
    private int updating = 0;
    private int oldEventMask = 0;
    
    // Constants from the Platform SDK.
    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;
    private const int PFM_ALIGNMENT = 8;
    private const int SCF_SELECTION = 1;
    
    // It makes no difference if we use PARAFORMAT or
    // PARAFORMAT2 here, so I have opted for PARAFORMAT2.
    [StructLayout( LayoutKind.Sequential )]
    private 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;
    }
    
    [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 );
}

/// <summary>
/// Specifies how text in a <see cref="AdvRichTextBox"/> is
/// horizontally aligned.
/// </summary>
public enum TextAlign
{
    /// <summary>
    /// The text is aligned to the left.
    /// </summary>
    Left = 1,
    
    /// <summary>
    /// The text is aligned to the right.
    /// </summary>
    Right = 2,
    
    /// <summary>
    /// The text is aligned in the center.
    /// </summary>
    Center = 3,
    
    /// <summary>
    /// The text is justified.
    /// </summary>
    Justify = 4
}

Conclusion

I'll add to this code in future posts and if anyone has any comments or suggestions (or even requests), feel free to ask them. Hope you found this useful.

I'm Back!

Pete Vidler — Sun, 22 Aug 2004 18:51:00 GMT

Nearly a year since my last post, I'm finally back (must have lost my password for a while, heheh).

Anyway, for the last year I've been applying for jobs like crazy. The news is that I won't be unemployed for much longer! In september I'm starting a Ph.D at Leicester University in the UK. I will be based in the Embedded Systems Laboratory and my project is to write a compiler for a not-yet-developed language targetting a not-yet-designed processor -- should be fun! So I'll be a student again, but this time they'll pay me for it (a professional student)! And I'm using way too many exclamation marks!

I've noticed that a lot of people have been commenting on my previous blog entries (particularly the ones on Extending RichTextBox). It's nice to see that people are finding these useful, but I can't really help anyone with the code that is there (I barely remember writing it). Sorry, but it shouldn't be too hard to work out if you play with it.

I've also changed my email address -- it's now pvidler@mailblocks.com and uses a challenge/response spam filter (so be prepared for an automated response if you send me email).