christo greeff

Amazon Kindle Fire

2011-09-28T19:29:00.001+02:00

The much speculated Amazon Kindle tablet was released earlier today. I must say, I should probably have waited a bit longer before ordering my Kindle. But then again, looking at the Kindle Fire my Kindle Keyboard is still what I would have bought.

I’ll wait for the reviews, but if you want the latest new toy from Amazon, buy the Kindle Fire, Full Color 7" Multi-touch Display, Wi-Fi.

The most interesting aspect of the Kindle Fire seems to be the Silk browser. Watch the short video below. It does make sense from a tablet perspective to leverage the Amazon EC2 service to speed up browsing on the device. Time will tell if it really makes such a big difference.

Silk Browser

Recruiters and talent

2010-03-07T12:52:00.000+02:00

From time to time I get emails from recruiters who either have my details on record or from my publicly available profile on LinkedIn. Now I don’t have a problem with them sending me the emails. It is always the content or the lack thereof that determines whether or not I click the delete button – a number of occasions the real position might have been wonderful, but the email (which is on many occasions just a copy and paste from the actual posting) did not address the true nature of the job. Many of these job emails always seem to lack the basic information that any potential job seeker need to make a decision.

There are many recruitment companies that are very good at what they do, but I wish *all* of them would read this post by Eric Lippert of Fabulous Adventures In Coding.

Information inadequacy of job postings seems to be a problem for many software developers looking for the next interesting position. I think recruiters should be made aware of this fact. And I think I will from now on be more vocal about what I expect to see in job emails/postings.

Taking the road less travelled

2009-07-27T08:12:00.001+02:00

Sometimes making a rash decision, turns out to be quite fulfilling. I took a couple of photographs and amongst them were these 2 pictures. Taken on my way home, just outside Cape Town. I took a left turn at a certain intersection, instead of driving across, like I normally do.

Sometimes we should apply this to software development also. Try a different approach to a known solution. It might end up being more interesting.

Pre-order Windows 7

2009-07-23T09:59:00.001+02:00

No, you can’t. Not in South Africa anyway. I spent a good couple of minutes (maybe more than 20) this morning trying how to pre-order, order, buy, rent and/or lease Windows 7.

So I’ve concluded that Microsoft does not want to sell Windows 7 to us. The Microsoft South Africa website has a buy/offers/upgrade page, but this does not even work properly.

Click the link and… no. I did not mean “South Africa 404 mspx”.

I recently (8 months ago) purchased a new notebook pre-installed with Windows Vista. So for a couple of months I’ve been running Windows 7 RC instead. Do I want to run Windows 7 in the future? Yes. Do I want to buy it? Yes.

So I pose this question to Microsoft: Will you please sell Windows 7 to me? Now? On pre-order?

Paging records using the ROW_NUMBER() function in SQL Server 2005

2008-10-27T11:22:00.001+02:00

Early this morning I was confronted with a question. In general I like questions. I don't always know the answer (contrary to popular belief), so it was one of those Monday morning questions that make you sit up and think for a couple of minutes.

How easy is it to implement paging in SQL Server?

I don't know. I have never had to use paging in SQL. I do know MySQL provides the LIMIT keyword that allow you to specify an offset with the amount of records you need. LIMIT 100,20 will return results 100 to 120.

What about SQL Server 2005. Well, there's an temporary table solution that I've heard of but haven't seen implemented, partly because I try to avoid temporary tables.

Well, we're in luck. SQL Server 2005 introduced a new function called ROW_NUMBER(). So how does it work?

select 
    result.Firstname,
    result.Lastname,
    result.Date
from 
    (select 
        Firstname, Lastname, Date,
        row_number() over (order by Date asc) as row
     from 
        RegisteredUsers) as result
where
    result.row >= 20 and 
    result.row <= 30

From the MSDN entry: "Returns the sequential number of a row within a partition of a result set, starting at 1 for the first row in each partition."

So it returns a sequential row counter within a partition of a result set. The only major remark is that you have to specify the ORDER BY clause, because it determines the order in which rows are assigned their row numbers.

The stored procedure below takes everything into account. Calling it requires you to specify a page number and a page size. The result set is also limited by the TOP expression to limit the number of results. I think it might help improve performance on large result sets.

create procedure dbo.GetCustomersPage
    @PageNumber int,
    @PageSize int
as 
begin

declare @Offset int
declare @Limit int

set @Offset = 1 + (@PageNumber - 1) * @PageSize
set @Limit = @Offset + @PageSize

select 
    result.Firstname,
    result.Lastname,
    result.Date
from 
    (select 
        top (@Limit)
        Firstname, Lastname, Date,
        row_number() over (order by Date asc) as row 
     from 
        RegisteredUsers) as result
where
    result.row between @Offset and @Limit

end

I think this solution is really simple and straightforward. Comments are always welcome and appreciated.

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP3)

C# Asynchronous methods with CallBack

2008-10-13T13:39:00.001+02:00

It has been quite a while since my last post, so I decided to create a follow-up to a post I made last year. At the time I showed how to overcome the “cross-thread operation not valid” problem when updating the user interface. For this post I decided to tackle something more or less along the same lines, but instead focusing more on how to perform an asynchronous operation with a callback.

When creating a single-threaded application we normally have to wait for a long-running operation, such as a call to the database, to complete before we can update the user interface again. This creates an application that appears to be slow and unresponsive. The reason is that the long-running operations block other operations from continuing.

So what do we do? Using C# it is fairly straightforward to delegate long-running operations to background threads, so that our foreground thread updating the user interface stays responsive and allow other operations to be completed.

For this post I chose to show the how to execute a callback when an asynchronous method completes. There are other methods to use such as using the EndInvoke() Call Pattern, using WaitHandles to Wait for the Call to complete or the Polling Call Pattern. I find a Callback makes the most sense to me.

From my experience I found the following events occur the most in the type of applications I write:

A control is clicked, indicating that some long-running operation will be fired
Controls on the user interface needs to be set
Long-running operation is started
Long-running operation retrieves/generates data/updates user interface and/or performs magic
Long-running operation ends
Controls on the user interface needs to be set/populated

If we look at my code example, the above-mentioned steps are mapped to the following methods:

private void buttonGo_Click(object sender, EventArgs e)
private void SetFormControls(bool Enabled) in Step 1
private bool SomeLongOperation() in Step 1
private bool SomeLongOperation()
private void SomeLongOperationCallBack(IAsyncResult result)
private void SetFormControls(bool Enabled) in Step 5

Now for the code. I've (over-)commented the code to help explain. The example starts an asynchronous operation, updates a control on the form and executes a callback when done. It's a simple example, but I am of the opinion that it covers all of the basics.

using System;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace WindowsFormsApplicationDemo
{
    public partial class frmDemo : Form
    {
        public frmDemo()
        {
            InitializeComponent();
        }

        // Creates a delegate with the same signature as the method used for a long operation
        // In this case we'll use SomeLongOperation()
        private delegate bool SomeLongOperationDelegate();

        // Creates a delegate with the same signature as the method used to update the UI
        // In this case we'll use UpdateUIHelper(string value)
        private delegate void UpdateUIDelegate(string value);

        // Creates a delegate with the same signature as the method used to set form controls
        // In this case we'll use SetFormControls(bool Enabled)
        private delegate void SetFormControlsDelegate(bool Enabled);

        /// <summary>
        /// User actions start the long-running operation
        /// Step 1, 2 and 3
        /// </summary>
        private void buttonGo_Click(object sender, EventArgs e)
        {
            SetFormControls(false);

            this.UpdateUI("Starting...");

            // create an instance of SomeLongOperationDelegate
            SomeLongOperationDelegate someLongOperationDelegate = new SomeLongOperationDelegate(this.SomeLongOperation);

            // start asynchronous operation, pass someLongOperationDelegate as a parameter, so we can get it back later on callback
            someLongOperationDelegate.BeginInvoke(new AsyncCallback(this.SomeLongOperationCallBack), someLongOperationDelegate);
        }

        /// <summary>
        /// Sets any controls on the form that you want to have set prior to starting the long operation
        /// </summary>
        /// <param name="Enabled">Enable or disable controls</param>
        private void SetFormControls(bool Enabled)
        {
            // update any controls here, if you want to (such as enable or disable controls)
            // this.buttonGo.Enabled = Enabled;
        }

        /// <summary>
        /// Long operation such as a call to the database
        /// Step 4
        /// </summary>
        /// <returns>bool value to indicate success</returns>
        private bool SomeLongOperation()
        {
            // perform some longish operation

            for (int i = 1; i < 8; i++)
            {
                this.UpdateUI(
                    new StringBuilder("Operation busy ").
                        Append(i.ToString()).
                        Append("... (Managed TID: ").
                        Append(Thread.CurrentThread.ManagedThreadId.ToString()).
                        Append(")").ToString());

                Thread.Sleep(150);
            }

            return true;
        }

        /// <summary>
        /// CallBack for the someLongOperationDelegate instance
        /// Step 5 and 6
        /// </summary>
        /// <param name="result">IAsyncResult object</param>
        private void SomeLongOperationCallBack(IAsyncResult result)
        {
            // original delegate passed in the asyncState parameter, get it back here
            ((SomeLongOperationDelegate)result.AsyncState).EndInvoke(result);

            // update the user interface
            this.UpdateUI(
                new StringBuilder("CallBack (Managed TID: ").
                    Append(Thread.CurrentThread.ManagedThreadId.ToString()).
                    Append(")").ToString());

            // start an asynchronous operation to set the controls on the form
            this.BeginInvoke(new SetFormControlsDelegate(this.SetFormControls), new object[] { true });
        }

        /// <summary>
        /// Checks whether or not an Invoke is required and calls the method accordingly
        /// </summary>
        /// <param name="value">value of string to go into the listbox</param>
        private void UpdateUI(string value)
        {
            // if the calling thread is not the same thread that created the controls to be updated
            // call an Invoke to update controls
            if (this.InvokeRequired)
                this.Invoke(new UpdateUIDelegate(this.UpdateUIHelper), new object[] { value });
            else
                this.UpdateUIHelper(value);
        }

        /// <summary>
        /// Updates the user interface with whatever needs to be updated
        /// </summary>
        /// <param name="value">value of string to go into the listbox</param>
        private void UpdateUIHelper(string value)
        {
            listboxResults.Items.Add(
                new StringBuilder(value).
                    Append(" (Parent Managed TID: ").
                    Append(Thread.CurrentThread.ManagedThreadId.ToString()).
                    Append(")").ToString());

            listboxResults.SelectedIndex = (listboxResults.Items.Count - 1);
        }
    }
}

Some afterthoughts:

Make sure that you understand delegates and their use. They are very helpful and are needed when you want to make more use of events you application.
Disable the controls that initiate the long-running operation if they are only needed for that purpose. Other controls such are grids or items that are updated to indicate progress, should be visible. Grids or controls populated with large amounts of data, may want to made invisible while the long-running operation is populating them.
Make sure that you understand how Winforms managed threads are used. It will help you understand why you need to Invoke to update controls.
When using BeginInvoke on a delegate, make sure you call EndInvoke to free any resources. When doing a this.BeginInvoke(...) and there are no results to harvest, you do not need to call EndInvoke(). Chris Sells has a paragraph or two in his book, Windows Forms Programming in C#. There are numerous discussions on BeginInvoke/EndInvoke available on the Internet, but from my experience, when following this simple rule, you should be ok.

Please feel free to comment on this post. It is always interesting to hear the opinions from other people.

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP3)

Base32 encoding in C#

2008-08-22T11:12:00.000+02:00

In my previous post, I hashed a C# uint value using the sdbm hashing function. But what if you want to convert the hashed value to Base32? Unfortunately there's no built-in function to accomplish this, but help is at hand.

I based my function on this implementation, making only 1 or 2 minor changes. You may also refer to RFC3548 for more reading on the subject.

    /// <summary>
    /// Encode to base 32 according to RFC3548
    /// </summary>
    /// <param name="data">byte array to encode</param>
    /// <returns>string value</returns>
    public static string Base32Encode(byte[] data, int size)
    {
        int i = 0;
        int index = 0;
        int digit = 0;
        int current_byte;
        int next_byte;

        StringBuilder result = new StringBuilder();

        while (i < data.Length)
        {
            // unsign
            current_byte = (data[i] >= 0) ? data[i] : (data[i] + 256);

            // is the current digit going to span a byte boundary
            if (index > (IN_BYTE_SIZE - OUT_BYTE_SIZE))
            {
                if ((i + 1) < data.Length)
                    next_byte = (data[i + 1] >= 0) ? data[i + 1] : (data[i + 1] + 256);
                else
                    next_byte = 0;

                digit = current_byte & (0xFF >> index);
                index = (index + OUT_BYTE_SIZE) % IN_BYTE_SIZE;
                digit <<= index;
                digit |= next_byte >> (IN_BYTE_SIZE - index);
                i++;
            }
            else
            {
                digit = (current_byte >> (IN_BYTE_SIZE - (index + OUT_BYTE_SIZE))) & 0x1F;
                index = (index + OUT_BYTE_SIZE) % IN_BYTE_SIZE;
                if (index == 0)
                    i++;
            }

            result.Append(alphabet[digit]);
        }

        // trim the result to a specific size
        return result.ToString().Substring(0, size <= result.Length ? size : result.Length);
    }

If you have a specific question (not necessarily related to this post), let me know and we can see what solutions are available.

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP3)

sdbm hashing in C#

2008-08-21T11:26:00.000+02:00

sdbm - Substitute DBM or Berkeley ndbm for Every UN*X Made Simple is a hashing function I have never used before. To be honest, hashing is something I hardly ever *cough*never*cough* use.

So, how do you convert the simple sdbm hashing function from C++ to C#. I'm not asking. I'm going to tell you, because from my search in Google, it seems not a lot of people have attempted. Luckily I remember most of the C++ basics. De-referencing (pointers), addresses... you know, the things you tend to forget when working with C#.

C++ code:

    static unsigned long sdbm(unsigned char *str)
    {
        unsigned long hash = 0;
        int c;

        while (c = *str++)
            hash = c + (hash << 6) + (hash << 16) - hash;

        return hash;
    }

C# code:

    /// <summary>
    /// sdbm hashing function
    /// </summary>
    /// <param name="byteArr">Array of bytes to hash</param>
    /// <returns>uint</returns>
    private uint sdbm(byte[] byteArr)
    {
        uint hash = 0;

        foreach (byte b in byteArr)
            hash = b + (hash << 6) + (hash << 16) - hash;

        return hash;
    }

The trick is to simply pass an array of bytes to the C# function. A byte in C# has the same size as the unsigned char datatype in C++. But how do I pass an uint object as an array of bytes? Simple.

    uint value = GetSomeIDFromSomewhere();
    uint Hash = sdbm(BitConverter.GetBytes(value));

The C# BitConverter class converts a value to an array of bytes, which is exactly what we needed for the sdbm function.

That's it. For the next post, I'll encode the hashed value to Base32. And as always, leave a comment if you found this useful.

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP3)

3G Data Charges

2008-07-05T18:59:00.001+02:00

Earlier I read a post by Jonathan Endersby on how Vodacom is violating Facebook copyright, by displaying/adding advertisements on the mobile versions of Facebook.

Someone made the following comment on his post:

Plus, does it result in extra bandwidth charges for the consumer? (Those little bits of information do add up over time.)

Yes, those little bits do add up over time, and recently ~~I've~~ Hannes and I also started wondering about those

The data bundle on 2779....... has already been depleted and out-of-bundle rates are applicable...

SMS's that I get whenever I've used my 3G data bundle.

These SMS's always arrive a day or two after I've depleted my bundle. I would have liked to be cut off immediately when I used my data bundle. If Vodacom charges me and everyone else the out-of-bundle rates for a day or two, they stand to generate a lot of additional income.

Quite of clever way of generating income. Just delay those "out-of-bundle" SMS's a day or two. Or am I paranoid?

HSL to RGB Conversion for GDI+

2008-06-30T11:19:00.001+02:00

I have something to confess.

I have never truly understood the difference between RGB and HSL. There, I said it. :-D

Sure, I understood the basic idea, but I have never made an effort to investigate exactly how to convert from HSL to RGB. So, in an attempt to form a better understanding, I wrote a simple class that can convert from a HSL colour to a RGB colour. C# already exposes the GetHue(), GetSaturation() and GetBrigtness() methods on an object instance of type System.Drawing.Color, so the conversion was a one way affair from HSL to RGB.

The code below is pretty self-explanatory. I implemented the conversion routine from Wikipedia and tested drawing some graphs using GDI+.

//----------------------------------------------------------------------
// Namespace Christo.GFX.Conversion
// Author: Christo Greeff
// Date: 24/June/2008
//----------------------------------------------------------------------
// 24/June/2008 : New: GFXConversionException, HSL
//----------------------------------------------------------------------

using System;
using System.Drawing;

namespace Christo.GFX.Conversion
{
    /// <summary>
    /// Color Util Exception
    /// </summary>
    public class GFXConversionException : Exception
    {
        public GFXConversionException(string message, Exception innerException)
            : base(message, innerException)
        {
            //ToDo: Implement if needed
        }
    }

    /// <summary>
    /// HSL (Hue/Saturation/Luminance) Class
    /// </summary>
    public class HSL
    {
        #region Private members

        /// <summary>
        /// private hue
        /// </summary>
        private double _h;

        /// <summary>
        /// private saturation
        /// </summary>
        private double _s;

        /// <summary>
        /// private luminance
        /// </summary>
        private double _l;

        #endregion

        /// <summary>
        /// Constructor
        /// </summary>
        public HSL()
        {
            try
            {
                this.HSLHelper(0, 0, 0);
            }
            catch (Exception ee)
            {
                throw new GFXConversionException("HSL Constructor Error", ee);
            }
        }

        /// <summary>
        /// Constructor with ARGB color
        /// </summary>
        /// <param name="color">System.Drawing.Color value</param>
        public HSL(Color color)
        {
            try
            {
                this.HSLHelper(color.GetHue() / 360.0, color.GetSaturation(), color.GetBrightness());
            }
            catch (Exception ee)
            {
                throw new GFXConversionException("HSL Constructor Error", ee);
            }
        }

        /// <summary>
        /// Constructor with RGB color
        /// </summary>
        /// <param name="R">Red component with a value from 0 to 255</param>
        /// <param name="G">Green component with a value from 0 to 255</param>
        /// <param name="B">Blue component with a value from 0 to 255</param>
        public HSL(byte R, byte G, byte B)
        {
            try
            {
                Color temp = Color.FromArgb(R, G, B);
                this.HSLHelper(temp.GetHue() / 360.0, temp.GetSaturation(), temp.GetBrightness());
            }
            catch (Exception ee)
            {
                throw new GFXConversionException("HSL Constructor Error", ee);
            }
        }

        /// <summary>
        /// Constructor with HSL
        /// </summary>
        /// <param name="Hue">Varies from magenta - red - yellow - green - cyan - blue - magenta, described as an angle around a circle from 0.0 - 360.0 degrees</param>
        /// <param name="Saturation">Varies from 0.0 and 1.0 and describes how "grey" the colour is, with 0 being completely unsaturated (grey, white or black) and 1 being completely saturated</param>
        /// <param name="Luminance">Varies from 0.0 and 1.0 and ranges from black at 0.0, through the standard colour itself at 0.5 to white at 1.0</param>
        public HSL(double Hue, double Saturation, double Luminance)
        {
            try
            {
                this.HSLHelper(Hue, Saturation, Luminance);
            }
            catch (Exception ee)
            {
                throw new GFXConversionException("HSL Constructor Error", ee);
            }
        }

        /// <summary>
        /// HSL Helper
        /// </summary>
        /// <param name="Hue">Varies from magenta - red - yellow - green - cyan - blue - magenta, described as an angle around a circle from 0.0 - 360.0 degrees</param>
        /// <param name="Saturation">Varies from 0.0 and 1.0 and describes how "grey" the colour is, with 0 being completely unsaturated (grey, white or black) and 1 being completely saturated</param>
        /// <param name="Luminance">Varies from 0.0 and 1.0 and ranges from black at 0.0, through the standard colour itself at 0.5 to white at 1.0</param>
        private void HSLHelper(double Hue, double Saturation, double Luminance)
        {
            try
            {
                this.H = Hue;
                this.S = Saturation;
                this.L = Luminance;
            }
            catch (Exception ee)
            {
                throw new GFXConversionException("HSL HSLHelper Error", ee);
            }
        }

        /// <summary>
        /// Set helper function
        /// </summary>
        /// <param name="value">value that must be between 0 and 1</param>
        /// <returns>double value</returns>
        private double SetHelper(double value)
        {
            try
            {
                return (value > 1) ? 1.0 : (value < 0) ? 0 : value;
            }
            catch (Exception ee)
            {
                throw new GFXConversionException("HSL SetHelper Error", ee);
            }
        }

        /// <summary>
        /// Gets or sets the Hue value
        /// </summary>
        public double H
        {
            get
            {
                return this._h;
            }
            set
            {
                this._h = this.SetHelper(value);
            }
        }

        /// <summary>
        /// Gets or sets the Saturation value
        /// </summary>
        public double S
        {
            get
            {
                return this._s;
            }
            set
            {
                this._s = this.SetHelper(value);
            }
        }

        /// <summary>
        /// Gets or sets the Luminance value
        /// </summary>
        public double L
        {
            get
            {
                return this._l;
            }
            set
            {
                this._l = this.SetHelper(value);
            }
        }

        /// <summary>
        /// <para>Convert from the current HSL to RGB</para>
        /// <para>http://en.wikipedia.org/wiki/HSV_color_space#Conversion_from_HSL_to_RGB</para>
        /// </summary>
        public Color Color
        {
            get
            {
                double[] t = new double[] { 0, 0, 0 };

                try
                {
                    double tH = this._h;
                    double tS = this._s;
                    double tL = this._l;

                    if (tS.Equals(0))
                    {
                        t[0] = t[1] = t[2] = tL;
                    }
                    else
                    {
                        double q, p;

                        q = tL < 0.5 ? tL * (1 + tS) : tL + tS - (tL * tS);
                        p = 2 * tL - q;

                        t[0] = tH + (1.0 / 3.0);
                        t[1] = tH;
                        t[2] = tH - (1.0 / 3.0);

                        for (byte i = 0; i < 3; i++)
                        {
                            t[i] = t[i] < 0 ? t[i] + 1.0 : t[i] > 1 ? t[i] - 1.0 : t[i];

                            if (t[i] * 6.0 < 1.0)
                                t[i] = p + ((q - p) * 6 * t[i]);
                            else
                                if (t[i] * 2.0 < 1.0)
                                    t[i] = q;
                                else
                                    if (t[i] * 3.0 < 2.0)
                                        t[i] = p + ((q - p) * 6 * ((2.0 / 3.0) - t[i]));
                                    else
                                        t[i] = p;
                        }
                    }
                }
                catch (Exception ee)
                {
                    throw new GFXConversionException("HSL Color Error", ee);
                }

                return Color.FromArgb((int)(t[0] * 255), (int)(t[1] * 255), (int)(t[2] * 255));
            }
        }

        /// <summary>
        /// Modify the current HSL brightness
        /// </summary>
        /// <param name="brightness">brightness value</param>
        /// <returns>HSL</returns>
        private HSL BrightnessHelper(double brightness)
        {
            try
            {
                this.L = this.L * brightness;
            }
            catch (Exception ee)
            {
                throw new GFXConversionException("HSL BrightnessHelper Error", ee);
            }

            return new HSL(H, S, L);
        }

        /// <summary>
        /// Modify the current HSL brightness
        /// </summary>
        /// <param name="brightness">brightness value</param>
        /// <returns>HSL</returns>
        public HSL Brightness(double brightness)
        {
            return this.BrightnessHelper(brightness);
        }

        /// <summary>
        /// Modify the current HSL brightness
        /// </summary>
        /// <param name="brightness">brightness value</param>
        /// <returns>Color</returns>
        public Color BrightnessC(double brightness)
        {
            return this.BrightnessHelper(brightness).Color;
        }
    }
}

As always, comments are welcome. Yes, even the critiquing ones.

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP3)

Tetrominoe

2008-06-02T09:46:00.001+02:00

I finished my Tetris clone on the weekend. I found it quite a simple game to write, and my console version has 4 main parts:

Tetrominoe class:
Tetrominoe properties, information on how to draw each of the 7 Tetrominoes, moving and rotation.

Grid class:
Grid properties, dropped Tetrominoes and processing of completed lines. Events indicate whether the Grid has been updated with a new Tetrominoe.

TetrisProcessor class:
This class overlays the current Tetrominoe on the Grid, fills the Grid with dropped Tetrominoes, checks whether a Tetrominoe can move and handles creation of new Tetrominoes. This is the class that performs all the processing for the game.

Main class:
The main class is the normal console application class, which interacts with the TetrisProcessor class. Keystrokes, drawing and timing of the game happens here.

The next step is to use this Tetris engine for a WPF version of the game. So the next time I post about this, expect a WPF Tetris clone, which I'll make available for download. ;-)

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP3)

How to rotate a non-jagged, rectangular (2d) array

2008-05-08T08:09:00.001+02:00

Have you ever needed to rotate (or turn) the contents of a 2d array (non-jagged: same width and height)? Well, recently I needed to do just that. A single function makes it possible.

Luckily it's not difficult at all. The rotation is really just a matter of re-arranging the contents of the array. In other words, moving each y dimension from the source array to the x dimension in the destination array.

namespace ConsoleAppRotateArr
{
    class Program
    {
        static void Main(string[] args)
        {
            // create a shape
            uint[,] shape = new uint[3, 3];
            shape[0, 0] = 1;
            shape[1, 0] = 1;
            shape[2, 0] = 1;
            shape[0, 1] = 0;
            shape[1, 1] = 0;
            shape[2, 1] = 1;
            shape[0, 2] = 0;
            shape[1, 2] = 0;
            shape[2, 2] = 0;

            // rotate the shape left
            shape = Rotate(shape, Rotation.Left);
        }

        /// <summary>
        /// Rotation direction
        /// </summary>
        enum Rotation
        {
            /// <summary>
            /// Turn left 90 degrees (counter clockwise)
            /// </summary>
            Left,

            /// <summary>
            /// Turn right 90 degrees (clockwise)
            /// </summary>
            Right
        }

        /// <summary>
        /// Rotate a non-jagged, rectangular array
        /// </summary>
        /// <param name="grid">Non-jagged, rectangular array</param>
        /// <param name="rotate">Rotation direction enum</param>
        /// <returns>Non-jagged, rectangular array</returns>
        static uint[,] Rotate(uint[,] grid, Rotation rotate)
        {
            // get array dimensions
            uint xl = (uint)grid.GetLength(0);
            uint yl = (uint)grid.GetLength(1);

            // only rotate non-jagged, rectangular array
            if (xl.Equals(yl))
            {
                uint[,] temp = new uint[xl, yl];

                for (int y = 0; y < yl; y++)
                    for (int x = 0; x < xl; x++)
                        if (rotate.Equals(Rotation.Right))
                            temp[yl - y - 1, x] = grid[x, y];
                        else
                            temp[y, xl - x - 1] = grid[x, y];

                return temp;
            }
            else
                return grid;
        }
    }
}

The approach is probably not suitable for very large arrays. This method however, was perfect for the small arrays, such as a tetris block. ;)

Like always, I would appreciate comments or suggestions on the code.

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP2)

Extending the TreeView control with drag & drop

2008-04-08T10:47:00.001+02:00

The TreeView control in C# is quite a useful control used to visualize items in a tree. Unfortunately (or fortunately, if you like figuring things out) you still have to write your code to allow drag and drop of the TreeNode items when you have populated the control.

I've written a simple BuilderTreeView component based on the TreeView control, which allows the TreeNode items to be drag and dropped.

So far the control has the following additional characteristics over the normal TreeView control:

Drag & Drop nodes
Move up/down of nodes
Move child nodes to the root
Auto scroll when dragging nodes up/down
Basic context menu

Below is the code. It's still in progress, and not final, but at least it's usable and I've tested it in some scenarios.

I do believe there are other ways of doing this, so leave a comment if you have experienced different ways of implementing drag & drop. :)

  1 namespace Builder
  2 {
  3     public class BuilderTreeView : TreeView
  4     {
  5         // private members
  6         private TreeNode _draggedNode = null;
  7         private ContextMenu _defaultContextMenu = null;
  8 
  9         /// <summary>
 10         /// MoveDirection enum
 11         /// </summary>
 12         private enum MoveDirection
 13         {
 14             MoveUp,
 15             MoveDown
 16         }
 17 
 18         // default constructor
 19         public BuilderTreeView()
 20         {
 21             // allow drag & drop
 22             this.AllowDrop = true;
 23 
 24             #region Create default context menu
 25 
 26             MenuItem[] menuItems = new MenuItem[] { 
 27             new MenuItem("Move to &Root", new EventHandler(DefaultContextMenu_MoveToRoot_Eventhandler)) { Name = "mniMoveToRoot" },
 28             new MenuItem("-"),
 29             new MenuItem("Move &Up", new EventHandler(DefaultContextMenu_MoveUp_Eventhandler)) { Name = "mniMoveUp" },
 30             new MenuItem("Move &Down", new EventHandler(DefaultContextMenu_MoveDown_Eventhandler)) { Name = "mniMoveDown" },
 31             new MenuItem("-"),
 32             new MenuItem("&Expand", new EventHandler(DefaultContextMenu_Expand_Eventhandler)) { Name = "mniExpand" },
 33             new MenuItem("&Collapse", new EventHandler(DefaultContextMenu_Collapse_Eventhandler)) { Name = "mniCollapse" },
 34             new MenuItem("-"),
 35             new MenuItem("E&xpand All", new EventHandler(DefaultContextMenu_ExpandAll_Eventhandler)) { Name = "mniExpandAll" },
 36             new MenuItem("C&ollapse All", new EventHandler(DefaultContextMenu_CollapseAll_Eventhandler)) { Name = "mniCollapseAll" },
 37         };
 38 
 39             // create contect menu
 40             this._defaultContextMenu = new ContextMenu(menuItems);
 41             this._defaultContextMenu.Popup += new EventHandler(_defaultContextMenu_Popup);
 42 
 43             // assign context menu
 44             this.ContextMenu = this._defaultContextMenu;
 45 
 46             #endregion
 47         }
 48 
 49         #region DefaultContextMenu/MenuItem Eventhandlers
 50 
 51         // DefaultContextMenu, Popup Eventhandler
 52         void _defaultContextMenu_Popup(object sender, EventArgs e)
 53         {
 54             // enable MenuItems when a node is selected
 55             for (int i = 0; i < _defaultContextMenu.MenuItems.Count - 1; i++)
 56                 _defaultContextMenu.MenuItems[i].Enabled = (this.SelectedNode != null);
 57 
 58             // enable nodes by criteria
 59             if (this.SelectedNode != null)
 60             {
 61                 // check if node is a root node
 62                 _defaultContextMenu.MenuItems["mniMoveToRoot"].Enabled = (this.SelectedNode.Parent != null);
 63 
 64                 // check if node is at the top
 65                 _defaultContextMenu.MenuItems["mniMoveUp"].Enabled = (this.SelectedNode.PrevNode != null);
 66 
 67                 // check if node is at the bottom
 68                 _defaultContextMenu.MenuItems["mniMoveDown"].Enabled = (this.SelectedNode.NextNode != null);
 69             }
 70         }
 71 
 72         // DefaultContextMenu, MoveToRoot MenuItem Eventhandler
 73         protected void DefaultContextMenu_MoveToRoot_Eventhandler(object sender, EventArgs e)
 74         {
 75             this.Nodes.Add((TreeNode)this.SelectedNode.Clone());
 76             this.SelectedNode.Remove();
 77         }
 78 
 79         // DefaultContextMenu, MoveUp MenuItem Eventhandler
 80         protected void DefaultContextMenu_MoveUp_Eventhandler(object sender, EventArgs e)
 81         {
 82             MoveNode(this.SelectedNode, MoveDirection.MoveUp);
 83         }
 84 
 85         // DefaultContextMenu, MoveDown MenuItem Eventhandler
 86         protected void DefaultContextMenu_MoveDown_Eventhandler(object sender, EventArgs e)
 87         {
 88             MoveNode(this.SelectedNode, MoveDirection.MoveDown);
 89         }
 90 
 91         // DefaultContextMenu, Expand MenuItem Eventhandler
 92         protected void DefaultContextMenu_Expand_Eventhandler(object sender, EventArgs e)
 93         {
 94             this.SelectedNode.Expand();
 95         }
 96 
 97         // DefaultContextMenu, Collapse MenuItem Eventhandler
 98         protected void DefaultContextMenu_Collapse_Eventhandler(object sender, EventArgs e)
 99         {
100             this.SelectedNode.Collapse();
101         }
102 
103         // DefaultContextMenu, ExpandAll MenuItem Eventhandler
104         protected void DefaultContextMenu_ExpandAll_Eventhandler(object sender, EventArgs e)
105         {
106             this.ExpandAll();
107         }
108 
109         // DefaultContextMenu, CollapseAll MenuItem Eventhandler
110         protected void DefaultContextMenu_CollapseAll_Eventhandler(object sender, EventArgs e)
111         {
112             this.CollapseAll();
113         }
114 
115         #endregion
116 
117         #region Drag Events
118 
119         // start node drag
120         protected override void OnItemDrag(ItemDragEventArgs e)
121         {
122             this._draggedNode = (TreeNode)e.Item;
123             this.SelectedNode = this._draggedNode;
124 
125             this.DoDragDrop(e.Item, DragDropEffects.Move);
126         }
127 
128         // create new node location
129         protected override void OnDragDrop(DragEventArgs drgevent)
130         {
131             if (drgevent.AllowedEffect.Equals(DragDropEffects.Move))
132             {
133                 // get node at drop location
134                 TreeNode dropNode = DroppedOnNode(drgevent);
135 
136                 // add to root if new node parent has no parent
137                 if (dropNode != null)
138                     dropNode.Nodes.Add((TreeNode)this._draggedNode.Clone());
139                 else
140                     this.Nodes.Add((TreeNode)this._draggedNode.Clone());
141 
142                 // remove original
143                 this._draggedNode.Remove();
144             }
145         }
146 
147         // set DragDropEffects
148         protected override void OnDragEnter(DragEventArgs drgevent)
149         {
150             // no external drag & drop allowed
151             drgevent.Effect = DragDropEffects.None;
152         }
153 
154         // set Effect when dragging over control items
155         protected override void OnDragOver(DragEventArgs drgevent)
156         {
157             // get node at drop location
158             TreeNode dropNode = DroppedOnNode(drgevent);
159 
160             // scroll if next/prev node is not visible
161             if (dropNode != null)
162                 if (dropNode.NextVisibleNode != null)
163                     if (!dropNode.NextVisibleNode.IsVisible)
164                         dropNode.NextVisibleNode.EnsureVisible();
165                     else
166                         if (dropNode.PrevVisibleNode != null)
167                             if (!dropNode.PrevVisibleNode.IsVisible)
168                                 dropNode.PrevVisibleNode.EnsureVisible();
169 
170             // valid if the node is not moving to itself, or to one of its child nodes
171             if (SameBranch(this._draggedNode, dropNode))
172                 drgevent.Effect = DragDropEffects.None;
173             else
174             {
175                 // expand collapsed node
176                 if (dropNode != null)
177                     dropNode.Expand();
178 
179                 drgevent.Effect = DragDropEffects.Move;
180             }
181         }
182 
183         // set UseDefaultCursors
184         protected override void OnGiveFeedback(GiveFeedbackEventArgs gfbevent)
185         {
186             gfbevent.UseDefaultCursors = true;
187         }
188 
189         #endregion
190 
191         #region Helper functions
192 
193         /// <summary>
194         /// Move a node
195         /// </summary>
196         /// <param name="node">TreeNode to move</param>
197         /// <param name="move">MoveDirection enum</param>
198         /// <returns>int</returns>
199         private void MoveNode(TreeNode node, MoveDirection move)
200         {
201             // default to "no move"
202             int Index = -1;
203             switch (move)
204             {
205                 // move up if a previous node is found
206                 case MoveDirection.MoveUp:
207                     if (node.PrevNode != null)
208                         Index = node.PrevNode.Index;
209                     break;
210 
211                 // move down if a next node is found
212                 case MoveDirection.MoveDown:
213                     if (node.NextNode != null)
214                         Index = node.NextNode.Index + 1;
215                     break;
216             }
217 
218             // if moveable
219             if (Index != -1)
220             {
221                 // check for root node
222                 if (node.Parent != null)
223                 {
224                     node.Parent.Nodes.Insert(Index, (TreeNode)node.Clone());
225                     this.SelectedNode = node.Parent.Nodes[Index];
226                 }
227                 else
228                 {
229                     this.Nodes.Insert(Index, (TreeNode)node.Clone());
230                     this.SelectedNode = this.Nodes[Index];
231                 }
232 
233                 node.Remove();
234             }
235         }
236 
237         /// <summary>
238         /// Get Node at mouse pointer location
239         /// </summary>
240         /// <param name="drgevent">DragEventArgs</param>
241         /// <returns>TreeNode</returns>
242         private TreeNode DroppedOnNode(DragEventArgs drgevent)
243         {
244             // get the drop point on the control
245             Point dropLocation = this.PointToClient(new Point(drgevent.X, drgevent.Y));
246 
247             // get the node at the drop point
248             return (this.GetNodeAt(dropLocation));
249         }
250 
251         /// <summary>
252         /// Check if a dragged node is the same, or on the same node branch
253         /// </summary>
254         /// <param name="dragnode">Node being dragged</param>
255         /// <param name="targetnode">Node being dragged to</param>
256         /// <returns>bool</returns>
257         private bool SameBranch(TreeNode draggedNode, TreeNode dropNode)
258         {
259             // at the root level
260             if (dropNode == null)
261                 return false;
262             else
263             {
264                 // check if it is the same node, else call recursively
265                 if (draggedNode.Equals(dropNode))
266                     return true;
267                 else
268                     return SameBranch(draggedNode, dropNode.Parent); // ;-)
269             }
270         }
271 
272         #endregion
273     }
274 }

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP2)

Building a TreeView tree from a MenuStrip

2008-04-03T11:03:00.001+02:00

Recently I needed to convert only the ToolStripMenuItems on a MenuStrip control to a tree in a TreeView control.

I created a simple static class which takes the MenuStrip object as the source, and fills a TreeView with the results. A single AddNode function is recursively called to add child nodes.

I have not looked at any optimizations or did much testing, but I thought someone might find it useful and make some insightful suggestions. :-)

 1 namespace Builder
 2 {
 3     /// <summary>
 4     /// BuilderException
 5     /// </summary>
 6     public class BuilderException : Exception
 7     {
 8         /// <summary>
 9         /// Default constructor
10         /// </summary>
11         /// <param name="Message">Exception Message</param>
12         /// <param name="ee">Inner Exception</param>
13         public BuilderException(string Message, Exception ee) : base(Message, ee) { }
14     }
15 
16     /// <summary>
17     /// TreeStructure class
18     /// </summary>
19     public static class TreeStructure
20     {
21         // private members
22         private static TreeView temp_treeview;
23 
24         /// <summary>
25         /// Build a TreeView structure given a MenuStrip object
26         /// </summary>
27         /// <param name="menustrip">MenuStrip source object</param>
28         /// <param name="treeview">TreeView destination object</param>
29         public static void Build(MenuStrip menustrip, TreeView treeview)
30         {
31             try
32             {
33                 // assign treeview object
34                 temp_treeview = treeview;
35 
36                 // get enumerator and start with root nodes
37                 IEnumerator ie = menustrip.Items.GetEnumerator();
38 
39                 while (ie.MoveNext())
40                     AddNode(null, (ToolStripItem)ie.Current);
41             }
42             catch (Exception ee)
43             {
44                 throw new BuilderException("Unable to build tree.", ee);
45             }
46         }
47 
48         /// <summary>
49         /// Add TreeView node (recursive)
50         /// </summary>
51         /// <param name="node">TreeNode</param>
52         /// <param name="item"ToolStripItem></param>
53         private static void AddNode(TreeNode node, ToolStripItem item)
54         {
55             try
56             {
57                 if (item.GetType().Equals(typeof(ToolStripMenuItem)))
58                 {
59                     // firstnode or child node
60                     if (node == null)
61                         node = temp_treeview.Nodes.Add(item.Text);
62                     else
63                         node = node.Nodes.Add(item.Text);
64 
65                     // get enumerator for dropdownitems
66                     IEnumerator ie = ((ToolStripMenuItem)item).DropDownItems.GetEnumerator();
67                     while (ie.MoveNext())
68                         AddNode(node, (ToolStripItem)ie.Current);
69                 }
70             }
71             catch (Exception ee)
72             {
73                 throw new BuilderException("Unable to add node.", ee);
74             }
75         }
76     }
77 }

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP2)

Online Community vs. Creative Labs vs. Daniel_K

2008-04-02T09:03:00.001+02:00

A lot of "vs." in the title. As the owner of a Creative Live! soundcard, I've recently followed the story about Daniel Kawakami (Daniel_K), who modded (changed) some Creative drivers allowing certain Creative soundcards to work better on Vista. Non-support for my soundcard is one of the reasons I had not yet updated my home PC to Vista.

Creative in turn threatened Daniel_K online resulting in a mini online revolt against Creative.

Now Daniel_K has spoken about the happenings of the last couple of days. It's an interesting read, and answers some of the questions surrounding this whole issue.

Personally I really hope Creative does some soul-searching and assists many thousands of their users by just fixing the drivers to work on Vista. If not, I will also have to part with my Creative hardware... or I will just have to stick with XP. *sigh*

Stupid System.Windows.Form.ToolTip()

2008-04-01T14:55:00.001+02:00

Last week I updated some legacy code (don't we all love that?). Updating the actual code was pretty straightforward, but I decided to add some visual elements to notify the user of validation issues.
To make a long story short, I decided to popup a ToolTip() whenever a user tabs away from a control and a validation error is raised.

 1         private void textBox1_Leave(object sender, EventArgs e)
 2         {
 3             // create new tooltip
 4             ToolTip tt = new ToolTip()
 5             {
 6                 Active = true,
 7                 IsBalloon = true,
 8                 ToolTipIcon = ToolTipIcon.Info,
 9                 ToolTipTitle = "Test",
10                 InitialDelay = 0
11             };
12 
13             // associate tooltip with control
14             tt.SetToolTip(textBox1, "Test");
15 
16             // show the tooltip
17             tt.Show("Stupid", textBox1, 3000);
18         }

Now this code (which I've simplified to illustrate) seems to work fine, but there's a snag. If the mouse cursor hovers above the control when the ToolTip() is displayed for that control, the ToolTip() stem points to the wrong location.

Move the mouse cursor away from the control, tab to the next control and it will point to the control you have specified. Google didn't really help. Some mentioning of the issue, but vary vague and non-specific.

So in the end, I resorted to writing a (static) class to determine whether the mouse cursor is above the control which will receive the ToolTip(), move the mouse away from the control and back again after the ToolTip() has been displayed (hiding the cursor doesn't work... I've tried). Not really elegant, but it works.

 1             // move mouse if mouse is over control, and show tooltip. else just show tooltip
 2             if (m.OverControl(control))
 3             {
 4                 m.MoveAway(control);
 5 
 6                 // associate tooltip with control
 7                 tt.SetToolTip(textBox1, "Test");
 8 
 9                 // show the tooltip
10                 tt.Show("Stupid", textBox1, 3000);
11 
12                 m.MoveBack();
13             }
14

Maybe someone has encountered the same problem? Maybe there's a better solution?

Environment:
Microsoft ® Visual Studio 2008
Microsoft ® .NET framework 3.5
Microsoft ® Windows XP (SP2)

It is not sunny

2007-12-12T11:33:00.001+02:00

Cape Town weather is harder to predict than the number of cash-in-transit heists that will be foiled today. Today was supposed to be sunny and warm... that's what my iGoogle page also tells me. I guess I'm still used to the ~330 days of sunshine in the Free State.

Look at the difference between today (left) and yesterday (right).

Oh well. It will probably clear up a little later, and completely ruin the validity of my post.

My Facebook shirt looks like a tent :)

2007-10-31T09:03:00.001+02:00

I attended the first Facebook Developers Garage at the River Club Golf and Conference Centre (Liesbeek Parkway, Observatory, Cape Town, South Africa) last night. And I must admit that it was a very interesting event.

Let me see. The speakers were: Joey da Silva (moodia), Trever Kinnear (moodia), Grant Flemming (Fontera), Eben de Wit (Microsoft), Ernst Kuschke (24.com), Dave Morin (Facebook), Christine da Silva (AlterSage), Riaan Nolan (3am.co.za) and Mark Levitt (Chesscube.com). Hope I didn't leave anyone out.

Personally I thought the format of the event was excellent. Each presenter had about 10 minutes to talk about a specific topic related to Facebook software development. Some of the presenters used more time, but I didn't feel that any of them did not deserve the time they used.

Topics presented ranged from Facebook usage statistics, Microsoft's involvement with Facebook, marketing, development tips, development obstacles and a live Q&A video conference with Dave Morin, Facebook Senior Platform Manager (left his post of Manager, Creation & Collaboration at Apple).

I have a Facebook application development idea or two, that I've discussed with Hannes, so I'll post about those at a later stage. Something I found interesting is that South Africa has the 6th largest user population of Facebook. Something to think about!

All in all, I really enjoyed the event and will definitely attend the next one - if organized as well as this one. And thanks to the organizers for my (slightly too big) Facebook shirt. It looks cool. :)

27 Dinner | CapeTown. Not for me.

2007-10-28T00:34:00.001+02:00

So I attended the 27 Dinner event this evening. I think Dave Duarte (and the others I'm not aware of) did a good job of organizing the event, and it looked like most people were enjoying it.

(mobile phone pic)

I enjoyed the talk by Phil Barrett on user experience, although I did find it quite annoying that some people kept on talking and laughing during his presentation. The the rest of the evening I found a little boring. I expected more presentations, or maybe some group discussions.

But then I realised that it was a dinner after all. People are supposed to talk to each other (read "network"), eat something, talk some more and then go home. Presentations and slideshows should not even be necessary. And that is what I expected - presentations about cool stuff.

So while I do think it's an interesting event , it's not an event that I would need to go to again. The food was good though. :)

10... Reasons... no! 1 Reason why you should use Agile Methods

2007-10-17T13:33:00.001+02:00

I just read this article on The Future of Software Development. The one thing that struck me from the article was the reference to "...few good men (or women!)..." needed to create truly useful software. Most developers are people who enjoy software development for what it is: creating something useful while learning something new and problems.

My (short) conclusion: Agile methods are for the aforementioned type of developers, whilst the Waterfall model is more suited to developers who create software as a job.

Stanford Cove

2007-10-07T19:49:00.001+02:00

Some panoramic photographs from the weekend. The first one was taken from the balcony overlooking Stanford Cove (2km before Gansbaai, from Hermanus' direction).

Second one was taken from the grass bank above Stanford Cove.

Pity it was a little cold. :)

Total Swartland Rally

2007-09-23T20:30:00.001+02:00

Went for a little outing this weekend. The event was round 7 of the Sasol South African National Rally Champoinships, which took place in the Western Cape.

We were marshalling SS9 (Special Stage 9) on Saturday, 22 September 2007, which turned out to be quite interesting. We were posted about 19km outside of Malmesbury (GPS Coordinates: S 33°14.560', E018°34.290'), just off the R45.

It was interesting to see the cars and drivers at the end of this stage, as it was the longest stage of the day, taking about 24 minutes to complete... some cars showing signs of a tough stage!!

Didn't have too much time taking photographs of the action, but the GPS timing devices are quite interesting. These are activated when a marshal sitting 300m from us pushes a button when a competitor car passes by.The only thing to do then, is to enter the car number on both the GPS units and press Yes. These times are later downloaded from the units. Not overly high-tech, but still very accurate.

Results of the rally can be found here.

Afrikaans GPS

2007-09-19T14:11:00.001+02:00

I quite like my little Garmin nuvi GPS. Today I discovered that it's possible to update the software, and even the voice files from the Internet.

I installed the WebUpdater software from the Garmin website, connected to the Internet and chose to update. It upgraded the latest software on the unit to v3.30. After a reset, it displayed that new software is installing. Running the WebUpdater software again, it displays that it can also install updated British English voice files (with improved voice quality) and also Afrikaans voice files... which I did.

I think my next little project will be to see if I can write an application to edit the poi.gpi files on the unit. I know it's possible to edit the XML of the .gpx files, and then upload it to the unit. But I want to figure out the structure of the .gpi files, as it is not widely known what the format should look like.

How torrents make them rich

2007-09-18T23:19:00.001+02:00

The whole MediaDefender saga interests me. For those of you who don't know:

"MediaDefender is a company which offers services designed to prevent and stop people who engage in alleged copyright infringement using peer-to-peer distribution, using unusual tactics such as flooding peer-to-peer networks with decoy files that tie up a user's computer."

I find the story interesting, because recently some internal MediaDefender emails and taped telephone conversations were leaked on the Internet.

In an interesting turn of events, TorrentFreak reports that apparently some music labels use statistics on P2P data to decide on whether or not to release music singles or not. I find this fascinating because the same music labels that use the P2P statistics to make decisions which affects their finances, is also opposed to P2P networks.

So how much is P2P actually hurting music sales? If they are comfortable enough to use P2P as a marketing research tool, are they really losing money on P2P music downloads? Surely these marketing research tactics are almost free, and can be offset against the illegal downloads from P2P networks. Sure there is some possible income losses, but P2P music downloads also serve as another marketing tool - to get new tracks/singles out there.

I am really suspicious of these music labels and their fights against P2P and sometimes... just sometimes... I get the feeling that music labels are disguising their love of P2P networks as hate. But that's probably just me. Any comments?

England

2007-09-15T08:18:00.001+02:00

I went to watch the cricket yesterday. It was better than being at work on a Friday afternoon. England played Australia, and lost. Unfortunately.

England also played South Africa in the Rugby World Cup 2007 yesterday and lost by 36 points. England 0 - 36 South Africa.

Not exactly a good sporting day for England then.

Update (2007-09-17): "Sport doesn't make the geekiness go away..." - Christo Greeff

Never Judge A Book By It's Cover

2007-09-09T14:38:00.000+02:00

I there's something you really enjoy doing, and feel that it's a dream worth following, go for it.

Warning: This will make you want to practise!

2007-09-06T19:35:00.000+02:00

This 12 year old, Conrad Oberg, really knows how to play Jimi Hendrix. The 7+ minute clip made me search for the nearest guitar, and since I'll need a lot of practise, I will only be posting again in 2012...

Watch clip

Smiley notes

2007-09-04T20:38:00.000+02:00

I do not like writing anymore. I struggle to figure out what I wrote down during meetings. Usually I can figure out the date, some action items and some smiley faces, which also sometimes become sad faces, depending on the meeting. Drawings work much better, but they usually attract attention from the other attendees that think I’m either not listening or goofing off.

So I’ve started using another cunning but very effective workaround. Meetings I attend always tend to end up with someone drawing a lot of boxes, lines, arrows, circles and other nameless shapes on the whiteboard. So I’ll rather sit and watch, listen to what they’re saying (sometimes even participate with elegant whiteboard drawing manoeuvres), understand the problem and afterwards (take note of this), take a photograph of the whiteboard with my mobile phone. For me at least that really seems to work.

After a meeting I “blueteeth” the image to my PC, adjust the contrast and print it out. And more often than not, I’ll remember exactly what was discussed during the meeting. I know there are some fancy drawing boards on the market that can print out what was drawn, but these devices are generally expensive and not used very often.

What do you take from meetings (except for the cookies)?

Wrist Control

2007-09-04T07:22:00.000+02:00

Internet, bicycles and rar.exe

2007-09-04T06:36:00.000+02:00

This article by Ob81 made me try and remember what, where and when my first Internet experience was.

"Katie would study all day. Drink and Party all night, and then hang out at a small computer room on campus and actually slept in there sometimes."

I never studied all day, but that is off topic. If I remember correctly, a friend's father worked at the district education department. We used to go there on a Saturday afternoon to download games from the Internet. And then the last 2km of the downloaded goods was transported home via bicycle on 5.25 inch floppy disk and/or 3.5 inch floppy (for those with newer, more expensive PCs) disk.

We used to RAR all the data to disk, because usually we downloaded more than we actually needed. This is still true today for most of us.

Since those days, the Internet has changed dramatically. Somehow it seemed to be more fun to download, cycle and rar.exe X a:\download.rar c:\download

Fixed

2007-09-02T10:39:00.000+02:00

I fixed my blog. Still don't like the differences (especially with regards to the preformatted code snippets) between Firefox and IE, but I'll live with it.

Update: To fix, I turned off all Javascript in Firefox, resulting in the blogspot reverting back to normal HTTP POST buttons to update widgets.

Blog problems

2007-08-30T07:12:00.000+02:00

I had to delete my previous blog, because the page widgets broke and was scattered all over my page. Now I have the same problems. Look at my Firefox Error Console screen.

It seems there's something wrong with the widgets manager on blogger.com when you have some malformed HTML/Javascript in one of your widgets.

That's a problem. How can I delete a widget, if the widget manager isn't loading, thus not allowing me to "widget manage" (delete) any widgets.

I welcome any suggestions.

Update: I really used to word widgets alot in this post. :)

Cross-thread Calls

2007-08-29T16:59:00.000+02:00

I was busy writing a small application and wanted to update a control on my Windows form using the BackgroundWorker class, that "executes an operation on a separate thread.", in .NET. But when I compiled and executed the following code

// Create new Backgroundworker object, 
// and execute on button click
private void btnDoWork_Click(object sender, 
                             EventArgs e)
{
    BackgroundWorker myWorker = 
        new BackgroundWorker();

    //create the work event handler
    myWorker.DoWork += 
        new DoWorkEventHandler(UpdateMyListBox);

    //run the asynchronous worker
    myWorker.RunWorkerAsync();
}

// worker implementation
private void UpdateMyListBox(object sender,
                             DoWorkEventArgs e)
{
    Random r = new Random();

    // add some random values to a listbox
    for (int i = 0; i < 100; i++) {
        lstRandomValues.Items.Add(
            r.Next().ToString());
    }
}

I was greeted with the following exception at runtime.

"Cross-thread operation not valid: Control 'lstRandomValues' accessed from a thread other than the thread it was created on."

Wonderful. I'm sure I've done this before, and it worked. After reading an MSDN forum I learned that this is new to .NET Framework 2.0. It was implemented because "...when a thread other than the creating thread of a control tries to access one of that control's methods or properties, it often leads to unpredictable results." So it does actually make sense, but I only wanted to update the ListBox and I know there's nothing else that will try to update or read from that while myWorder thread is running. The simplest solution it seems is to add the

Control.CheckForIllegalCrossThreadCalls = false;

line, when your application starts. This will disable the catch of calls on the wrong thread that access a control's Handle property.

But we don't like cheating, do we? So the correct way to do it is by changing the code to the following.

// create new delegate
private delegate 
    int UpdateMyListBoxHandler(String message);

// Create new Backgroundworker object,
// and execute on button click
private void btnDoWork_Click(object sender, 
                             EventArgs e)
{
    BackgroundWorker myWorker = 
        new BackgroundWorker();

    //create the work event handler
    myWorker.DoWork += 
        new DoWorkEventHandler(UpdateMyListBox);

    //run the asynchronous worker
    myWorker.RunWorkerAsync();
}

// worker implementation
private void UpdateMyListBox(object sender, 
                             DoWorkEventArgs e)
{
    Random r = new Random();

    // add some random values to a listbox
    for (int i = 0; i < 100; i++) {

        /*Gets a value indicating whether the 
          caller must call an invoke method 
          when making method calls to the control 
          because the caller is on a different 
          thread than the one the control was 
          created on. */
        
        if (lstRandomValues.InvokeRequired)
        {
            /* Executes a delegate asynchronously 
               on the thread that the control's 
               underlying handle was created on. */
            lstRandomValues.BeginInvoke(
                new UpdateMyListBoxHandler(
                    lstRandomValues.Items.Add), 
                    r.Next().ToString());
        }
    }
}

1.) We created a delegate to execute on the same thread as the one the listbox handle was created on.
2.) Then in our thread we check by InvokeRequired, if processing happens on the same thread as the thread the listbox handle was created on.
3.) If invoke is required (which it will always in this example, I think) :) , we execute the delegate asynchronously with parameters, on the same thread the listbox handle was created on.

So the solution is slightly more complex than the original, but it's the correct way to do it.

Let me know if it needs a little more explaining.

Office cleaning products

2007-08-29T07:52:00.001+02:00

Check out that fake smile and perfect hair. It seems to be a common trend in companies to arm the cleaning staff with a never ending supply of Mr Min.

Me: "Where's the coffee?"
Company: "We've run out for the month."
Me: "What?!"
Company: "Employees drink too much coffee, and we're not buying more this month. Drink water."
Me: "Hu?"
Cleaning staff: "Sorry. Can I clean your desk?" [Takes cap of Mr Min can]
Me: "Hey. Wait! Don't spray my desk. Or my computer. Or anywhere near me."
Cleaning staff: "Eh, no cleaning? It has nice smell, and makes shiny desk."
Me: "Why? The desk isn't even real wood? And it does not smell good."
Cleaning staff: "Eish" [Looks bewildered]
Me: "Don't you ever run out of Mr Min? You spray like a million desks per day."
Cleaning staff: "No" [Moving on the next desk]
Me: *sigh* *sneeze*

Post Disclaimer: The characters and events depicted in this blog is fictitious. Any resemblance to specific events or persons is entirely accidental.

People are not well cough

2007-08-28T07:22:00.000+02:00

I hate salad. It's green and tastes like nothing, especially cucumber. Rabbits like it though. But (apparently) salad is good for you, so once in a while I'll sooth my conscience by eating some of the green stuff. I also try to visit the gym as much as possible, though probably not enough. And I avoid fast foods as much as possible. Especially that place with the clown guy… Ronald. So where am I going with this post?

Sick people. Just to be safe, I’ll refer to them as unwell. I know some people who are unwell all the time. If it’s not flu, it’s a headache. They cough and sneeze. Complain all the time and drink pills. Especially the complaining! “Oh, I feel so sick.” “Oh, my whole body is in pain.” What’s going on?

And then you start to notice small things. Normally (and I’m making a very big assumption here… “assumption is the mother of all f***-ups”) these unwell people don’t live healthy lifestyles. Fatty food for breakfast. Too much coffee. Zero exercise. Smoking. Drinking in excess. And that’s just the things I know about.

Come on people. If you want to feel a little healthier, get sick less often, have less headaches, start living healthier life. And stop complaining!! I can’t take the complaining anymore!!

PS: I just noticed this post was about me, not being able to take the complaining anymore.

Panoramic pic

2007-08-22T08:31:00.001+02:00

Let me start with a panoramic shot from the office. Check Autostitch on how to create photographs like this.

Version 2.0

2007-08-22T08:27:00.000+02:00

Blogger.com ate my previous blog. Hence version 2.0.

christo greeff

Amazon Kindle Fire

Recruiters and talent

Taking the road less travelled

Pre-order Windows 7

Paging records using the ROW_NUMBER() function in SQL Server 2005

C# Asynchronous methods with CallBack

Base32 encoding in C#

sdbm hashing in C#

3G Data Charges

HSL to RGB Conversion for GDI+

Tetrominoe

How to rotate a non-jagged, rectangular (2d) array

Extending the TreeView control with drag & drop

Building a TreeView tree from a MenuStrip

Online Community vs. Creative Labs vs. Daniel_K

Stupid System.Windows.Form.ToolTip()

It is not sunny

My Facebook shirt looks like a tent :)

27 Dinner | CapeTown. Not for me.

10... Reasons... no! 1 Reason why you should use Agile Methods

Stanford Cove

Total Swartland Rally

Afrikaans GPS

How torrents make them rich

England

Never Judge A Book By It's Cover

Warning: This will make you want to practise!

Smiley notes

Wrist Control

Internet, bicycles and rar.exe

Fixed

Blog problems

Cross-thread Calls

Office cleaning products

People are not well *cough*

Panoramic pic

Version 2.0

People are not well cough