Bee Eee Blog

Here’s the code to set the position of the caret in a richedit control

int position = 12;
richedit1.Select( position, 0 );
richedit1.ScrollToCaret(); // if you want the position to be shown

It’s that simple.

I recently changed from a TextEdit control to a ComboBox and was somewhat annoyed that there wasn’t a property that forced the input characters to all be uppercase.  So I dug around and came up with the following method using the KeyPress event.

         private void productNumber_KeyPress(object sender, KeyPressEventArgs e)
        {
            char c = e.KeyChar;
            // make it uppercase only
            if (c >= 'a' && c <= 'z')
            {
                int digit = (int)c;
                digit = digit - 'a' + 'A';
                e.KeyChar = Convert.ToChar(digit);
            }
        }

When the event handler is called it gives you a chance to edit the hit character. Just by changing e.KeyChar you change the actual input character. This is a nifty trick to have under your belt.

I recently was getting greatly annoyed with some drawing code in my program.  I was drawing a photo that I could zoom and move around.  When I zoomed with the wheel though it would briefly draw the image in two positions.  The first position after it was zoomed, and the second position after it was re-centered on the screen.  Well this looked awful.  Not exactly professional looking.  So I tried a hundered different things.  I tried setting a bool variable in the control to tell the paint function not to draw.  No good.  The drawing was done with asynchronous messages.  Then I tried  BeginInvoke.  That didn’t work also.  I tried SuspendLayout and ResumeLayout functions of the Control class:  No good.  Finally I just used the Visible property which kind of worked, well I didn’t get the double picture, but my background was light color and the foreground dark, so there was still a bad looking flicker.  After a couple of hours I finally found the solution at: http://weblogs.asp.net/jdanforth/archive/2004/03/12/88458.aspx. I worked on the example a little and boiled it down to two functions: StopDrawing and StartDrawing.

The techinque basically turns of drawing and events to the object on the win32 level underneath .Net.  This is very handy and it worked very very well.  Here is the code.

        using System.Runtime.InteropServices;
        private const int WM_SETREDRAW      = 0x000B;
        private const int WM_USER           = 0x400;
        private const int EM_GETEVENTMASK   = (WM_USER + 59);
        private const int EM_SETEVENTMASK   = (WM_USER + 69);

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

        IntPtr eventMask = IntPtr.Zero;

        public void StopDrawing()
        {
            if (drawStopCount == 0)
            {
                // Stop redrawing:
                SendMessage(this.Handle, WM_SETREDRAW, 0, IntPtr.Zero);
                // Stop sending of events:
                eventMask = SendMessage(this.Handle, EM_GETEVENTMASK, 0, IntPtr.Zero);
            }
            drawStopCount++;
        }

        public void StartDrawing()
        {
            drawStopCount--;
            if (drawStopCount == 0)
            {
                // turn on events
                SendMessage(this.Handle, EM_SETEVENTMASK, 0, eventMask);

                // turn on redrawing
                SendMessage(this.Handle, WM_SETREDRAW, 1, IntPtr.Zero);

                Invalidate();
                Refresh();
            }
        }

Here is a little nice bit of code to get text to jump out at you no matter what the background.  Outlined text is especially useful when putting text on an image and don’t have control of the background contrast. Basically it draws a black boarder with a while fill.

// prepare to draw text

StringFormat sf = new StringFormat();

sf.Alignment = StringAlignment.Center;

sf.LineAlignment = StringAlignment.Center;// draw the text to a path

System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();

path.AddString(text, Font.FontFamily, 0, 14.0f, fillRect, sf);

// fill in the outline

g.FillPath(Brushes.White, path);

// draw the outline

g.DrawPath(new Pen(Color.Black,2.0f) , path);

Tiff files are interesting.  They are like the all inclusive file format.  It is an extremely flexible file format that allows for many types of pixel formats that other image formats couldn’t possibly handle.  For instance 16 bits per channel or sample in the Tiff lingo.  Event the possibility of 4 or 5 samples per pixel.  If you wanted you could have a Red, Green, Blue, IR, Alpha channel.  Although software would have a difficult time displaying the image.  Anyway I digress — tiff being somewhat flexible is also some what difficult to manage, this is where libtiff comes in handy.  It handles most of this for us.

The first step is to add using System.Runtime.InteropServices; to you module. Then add the stubs for the libtiff functions as follows:

    static class TiffHandler
    {
        [DllImport("libtiff3.dll")]
        private static extern int TIFFOpen(String image_path, String opts);
        [DllImport("libtiff3.dll")]
        private static extern void TIFFClose(int handle);
        [DllImport("libtiff3.dll")]
        private static extern void TIFFGetField(int handle, uint property, ref UInt32 value );
        [DllImport("libtiff3.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        private static extern int TIFFSetField(int handle, uint property, uint value);
        [DllImport("libtiff3.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        private static extern int TIFFSetField(int handle, uint property, string value);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFReadRGBAImage(int handle, UInt32 width, UInt32 height, byte *raster, int Unkown);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFReadEncodedStrip(int handle, int strip, byte* buf, int size);
        [DllImport("libtiff3.dll")]
        private unsafe static extern byte* _TIFFmalloc(UInt32 size);
        [DllImport("libtiff3.dll")]
        private unsafe static extern void _TIFFfree(byte* pointer);
        [DllImport("libtiff3.dll")]
        private unsafe static extern void TIFFWriteEncodedStrip(int handle, int offset, byte* buffer, int size);
        [DllImport("libtiff3.dll")]
        private static extern uint TIFFScanlineSize(int handle);
        [DllImport("libtiff3.dll")]
        private static extern int TIFFDefaultStripSize(int handle, int size);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFWriteScanline(int handle, byte* buffer, int row, int sample);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFReadScanline(int handle, byte* data, int row, int sample);

Next we add the constants. I’m not going to add them all there are thousands of them but here is an example of the ones that are used in writting a tiff. If you want more look in the libtiff header files. It seems like it’s in tiff.h

        const uint TIFFTAG_IMAGEWIDTH = 256;	/* image width in pixels */
        const uint TIFFTAG_IMAGELENGTH	= 257;	/* image height in pixels */
        const uint TIFFTAG_BITSPERSAMPLE = 258;	/* bits per channel (sample) */
        const uint TIFFTAG_SAMPLESPERPIXEL = 277;	/* samples per pixel */
        const uint TIFFTAG_COMPRESSION	= 259;	/* data compression technique */
        const uint COMPRESSION_DEFLATE	= 32946;	/* Deflate compression */
        const uint PHOTOMETRIC_RGB = 2;	/* RGB color model */
        const uint TIFFTAG_PLANARCONFIG = 284;	/* storage organization */
        const uint PLANARCONFIG_CONTIG	= 1;	/* single image plane */

And then the code to write out the image to a file:

        public static unsafe void SaveTiff(string fileName, ImageArray array)
        {
            int tif = TIFFOpen(fileName, "w");
            int Samples = 3;

            TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, (uint)array.Width);
            TIFFSetField(tif, TIFFTAG_IMAGELENGTH, (uint)array.Height);
            TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
            TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
            TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
            TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16);
            TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, (uint)Samples);
            TIFFSetField(tif, TIFFTAG_ARTIST, "Bee Eee Inventions, LLC");

            int cnt = array.Width * array.Height;
            int size = (cnt * Samples * sizeof(ushort));
            ushort* buffer;

            buffer = (ushort*)_TIFFmalloc((uint)size);

            // We set the strip size of the file to be size of one row of pixels
            //int RowSize = TIFFDefaultStripSize(tif, array.Width*3);

            // copy data into buffer
            int i,pos,ptr=0;
            for (i = 0, pos = 0; i < cnt; i++, pos += Samples, ptr++)
            {
                buffer[pos] =  (ushort)(array.Data[ptr].r);
                buffer[pos + 1] = (ushort)(array.Data[ptr].g);
                buffer[pos + 2] = (ushort)(array.Data[ptr].b);
            }

            // Write the information to the file
            TIFFWriteEncodedStrip(tif, 0, (byte *)buffer, size);

            TIFFClose(tif);

            _TIFFfree((byte *)buffer);
        }

Enjoy. Next article I’ll show you how to read some tiff files. Opening all tiff files could be difficult. :)

Often times it is desirable to draw a string with a System.Drawing.Graphics. My problem came when drawing text over an image. The image itself is dark but had light spots in it. This can make seeing the text very difficult. To fix the problem I fill a box behind the text. To do that I need to know how tall and wide the text will be.

The magic function is Graphics.MeasureString. This functions returns the calculated size of the string that is being drawn.

// measure the string
StringFormat sf = new StringFormat();
sf.Alignment = StringAlignment.Near;
sf.LineAlignment = StringAlignment.Near;
SizeF boundry = g.MeasureString(ToString(), font);

// draw the string
Rectangle textRect = new Rectangle(10, 10, (int)(boundry.Width + 2), (int)(boundry.Height + 2));
g.FillRectangle(Brushes.Black, textRect);
g.DrawRectangle(Pens.White, textRect);
g.DrawString(ToString(), font, Brushes.Yellow, textRect.X, textRect.Y, sf);

c# and gdi+ have a simple way to control the colors that are drawn. It’s basically a ColorMatrix. It’s a 5×5 matrix that is applied to each color if it is set.

Adjusting brightness is just preforming a translate on the color data, and contrast is preforming a scale on the color. Gamma is a whole different form of transform, but it’s included in ImageAttributes which accepts the ColorMatrix.

So here’s the simple code:

            Bitmap origanalImage;
            Bitmap adjustedImage;
            double brightness = 1.0f; // no change in brightness
            double constrast = 2.0f; // twice the contrast
            double gamma = 1.0f; // no change in gamma

            float adjustedBrightness = brightness - 1.0f;
            // create matrix that will brighten and contrast the image
            float[][] ptsArray ={
                    new float[] {contrast, 0, 0, 0, 0}, // scale red
                    new float[] {0, contrast, 0, 0, 0}, // scale green
                    new float[] {0, 0, contrast, 0, 0}, // scale blue
                    new float[] {0, 0, 0, 1.0f, 0}, // don't scale alpha
                    new float[] {adjustedBrightness, adjustedBrightness, adjustedBrightness, 0, 1}};

            imageAttributes = new ImageAttributes();
            imageAttributes.ClearColorMatrix();
            imageAttributes.SetColorMatrix(new ColorMatrix(ptsArray), ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
            imageAttributes.SetGamma(gamma, ColorAdjustType.Bitmap);
            Graphics g = Graphics.FromImage(adjustedImage);
            g.DrawImage(originalImage, new Rectangle(0,0,adjustedImage.Width,adjustedImage.Height)
                ,0,0,bitImage.Width,bitImage.Height,
                GraphicsUnit.Pixel, imageAttributes);

So there it is. Simple enough isn’t it.

It seems I left out something that helps the quality of the .Net provided form double buffering when you are doing custom drawing. Just override OnPaintBackground and leaving it blank. This prevents the background from being momentarily drawn when you don’t want it to be.

so again here’s how to enable double buffering on the form:

this.SetStyle(
          ControlStyles.AllPaintingInWmPaint |
          ControlStyles.UserPaint |
          ControlStyles.DoubleBuffer,true);

And then the override

protected override void OnPaintBackground(PaintEventArgs e)
{
}

If you’ve ever used a message queue to talk to different parts of your application you know that sometimes you run into a problem with tangled call stacks; especially if one message can causes another message to be sent.

However, in c# .Net there is a simple way to untangle the call stack of the message queue. Just use the BeginInvoke method. This unwinds the stack and uses a delegate to call your message reception handler from the control’s thread.

For instance:

delegate void PostOfficeMessageHandler( POMessage message );

public void SendMessage(Control Sender, POMessage Message)
{
    PostOfficeMessageHandler mh = recipients[Sender];
    Sender.BeginInvoke(mh, Message);
}

The advantages of this method of deliver are two fold. 1. The stack is unwound. 2. It makes message handler in the control’s threads solving some threading issues.

There are a couple of disadvantages. 1. Extra overhead. 2. If the message causes problems you may not know where it’s coming from!

I’m developing a component that is like the sidebar in the Visual C# Express (c). To get it to appear when the mouse is over the control isn’t a problem, however I soon discovered that using the MouseEnter and MouseLeave didn’t work. When I went over child controls the MouseLeave would be called and cause my sidebar to collapse.

Instead I had to create a global mouse hook so that no matter what control the mouse was over I could get a mouse event.

First was the code to import the hook function:

// create a mouse over eventstatic int WH_MOUSE_LL = 14;
[System.Runtime.InteropServices.DllImport("kernel32.dll")]
static extern IntPtr GetModuleHandle(string moduleName);

[System.Runtime.InteropServices.DllImport("user32.dll")]
static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, uint dwThreadId);

[System.Runtime.InteropServices.DllImport("user32.dll")]
public static extern int UnhookWindowsHookEx(IntPtr hhook);

[System.Runtime.InteropServices.DllImport("user32.dll")]
static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, uint wParam, IntPtr lParam);
delegate IntPtr HookProc(int nCode, uint wParam, IntPtr lParam);

private HookProc hookProc;
private IntPtr hook;

Here is the event handler

IntPtr LowLevelMouseProc(int nCode, uint wParam, IntPtr lParam)
{
    // get the current mouse position
    Point p = Cursor.Position;

    // convert to client rectangle to screen position
    Rectangle r = RectangleToScreen(ClientRectangle);

    // check to see if mouse is within control bounds
    bool exp = (p.Y > r.Top && p.Y < r.Bottom && p.X > r.Left && p.X < r.Right);

    // adjust the expansion
    if (exp != Expanded)
         Expanded = exp;

    // Finished with this
    return CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam);
}

Then the initialization code I put in the OnLoad event handler:

if (!DesignMode)
{
    hookProc = new HookProc(LowLevelMouseProc);
    hook = SetWindowsHookEx(WH_MOUSE_LL, hookProc, GetModuleHandle(null), 0);
}

And then code for closing in the OnHandleDestroyed event handler:

protected override void OnHandleDestroyed(EventArgs e)
{
        UnhookWindowsHookEx(hook);
        base.OnHandleDestroyed(e);
}

That should just about do it then. Now the UserControl can sense whether the mouse is overhead whether or not the mouse is over a child control.