I’ve refreshed the site for PodTower – head over to the PodTower Site to check it out. Note that it’s now under the guise of SilverFinn – my new, professional blog. There’s a new version of PodTower on the vanguard, so look out for it.

Over the past while I’ve found that I’ve been writing code for myself over and over again to do a bunch of generic tasks in WPF (drag and drop, etc). So, I’ve decided to combine all this generic code into a project called Elias’ WPF Libraries!

Head over to http://eliaswpflibs.codeplex.com/ to check it out.

Tonight, I was too lazy to set up CVS or Git, so I somehow deduced that writing my own Powershell script to do basic source control made more sense. Just in case anyone else is looking for something similar, here it is.

The script works as follows: You pass in a list of folders you wish to "check-in", and it copies them, excluding bin and obj directories, to .\.es\yyyyMMddHHmmss\(Names). Optionally, if you want to mark something as "stable", you can include the "-stable" flag. If you want to give the folder a more descriptive name, you can include the "-tag" flag, and the script will ask for a name.

$checkinfolder = get-date -format "yyyyMMddHHmmss"
$currentloc = get-location
$promoteAsStable = $FALSE

foreach($arg in $args)
{
    if($arg.ToLower().Equals("-tag"))
    {
        $checkinfolder = read-host "Check-in as tagged revision path"
    }
}

new-item $currentloc\.es\$checkinfolder -type Directory | out-null

foreach($arg in $args)
{
    if($arg.ToLower().Equals("-stable"))
    {
        $promoteAsStable = $TRUE
    }
    else
    {
        echo "Checking in $arg..."
        get-childitem .\$arg -Exclude "Bin","Obj" | copy-item -Destination .es\$checkinfolder\$arg
    }
}

$comment = read-host "Check-in Comment for $checkinfolder"

if($promoteAsStable -eq $TRUE)
{
    $checkinfolder | out-file -filepath ".\.es\STABLE" -append
}
$comment | out-file -filepath ".\.es\$checkinfolder.txt"

$checkinfolder | out-file -filepath ".\.es\CHECKINS" –append

Hopefully you’ll find it useful.

Tonight, I worked some more on Ubox. Since having been introduced to demos, there has been one effect I’ve always wanted to try coding – the LED-sign style scroller. In theory, it’s easy enough – plot pixels. However, I tried to take it a step further.

My first attempt involved testing copying one array of integers to another, column by column, to simulate the effect of scrolling. While this worked, I quickly realized how inefficient it is. To store the 26 letters of the alphabet as arrays of integers, size 8x8 would require on a 32-bit machine, 4 x 64 x 26 = 6656 bytes, or around 6KB. Doesn’t sound like a lot of memory? It might not be these days, but it’s inefficient as hell. After doing some thinking, I realized that for the scroller, I only wanted two colors – a light red and a dark red. With this in mind, I realized I could do some primitive compression. If we have 8x8 scroller character data, we need to store 64 bits, or 8 bytes of information per character. That works out to two 32-bit integers on a Win32 machine. With this in mind, I cut the space requirement from 6656 bytes to 208 bytes.

To implement this, I built a separate helper program in C#. Enter the worlds worst monochrome graphics editor.

Yes, it’s done in WinForms. Yes, I know how to use WPF. Yes, the program is a total hack. But it works. Basically, the checkboxes represent what one would expect to be an “on” state. Output gives me the integer array representing the character data. For instance,

int stuff[53] =
{
0x66663C3C, 0x66667E66, 0x7E82827E, 0x7E82827E, 0x6063C78, 0x783C0606, 0x42427E3E, 0x3E7E4242, 0x3E023E7E, 0x7E3E021E, 0x3E023E7E, 0x202021E, 0x6067E3C, 0x7C7E4676, 0x7E666666, 0x6666667E,
0x18187E7E, 0x7E7E1818, 0x3730FCFC, 0x1E3E3237, 0x1E366606, 0x66361E0E, 0x6060606, 0x3C7E0606, 0xD6FEEEC6, 0xC6C6C6C6, 0xCFC7C3C3, 0xC3E3F3DB, 0x66667E1C, 0x3C7E6666, 0x6666663E, 0x606063E,
0x66667618, 0xD8FE7676, 0x46467E3E, 0x66361E3E, 0x606063C, 0x3C60603C, 0x18183C7E, 0x18181818, 0x66666666, 0x387E6666, 0xC3C3C300, 0x183C66C3, 0xC3C3C3C3, 0x66FEDBDB, 0x183CE7C3, 0xC3C3663C,
0x3C666666, 0x18181818, 0x30607C7E, 0x7E3E0C18, 0x0, 0x0
};

…represents my horribly-drawn 26-character-plus-space alphabet.

Next came the implementation. I keep track of the current “column” being displayed in the scroller, along with the ASCII string being displayed. The ASCII string is used to plot each character.

          
  1: for(int i
= 0; i < 96; i++) 
          
  2: {

          
  3:   //
Drawing routine for pixel scroller.
          
  4: 

          
  5:   //
PSet(xLet + (x << scale), 50 + (y << scale), pixDt[2], pixDt[1], pixDt[0],
screen);
          
  6: 

          
  7:   int currCol
= (col + i) % len; 
          
  8:   char letter
= scroller[currCol / 8]; 
          
  9:   if(letter
== 32) 
          
 10:   {

          
 11:     for(int y
= 0; y < 8; y++) 
          
 12:     {

          
 13:       //
col
          
 14:       PSet(xLet + (i << scale), 125 + (y << scale), 140, 0, 0, screen);

          
 15:     }

          
 16:   }

          
 17:   else
          
 18:   {

          
 19:     for(int y
= 0; y < 4; y++) 
          
 20:     {

          
 21:       int realLetter
= letter - 0x41; 
          
 22: 

          
 23:       //
Idea: top half is in MSB of stuff[realLetter]
          
 24:       //
bottom in LSB of stuff[realLetter + 1]
          
 25: 

          
 26:       int t1
= ((8 * y) + (currCol % 8)); 
          
 27:       int t2
= stuff[realLetter * 2] >> t1; 
          
 28:       Uint8 g1 = (t2 & 0x1) == 0x1 ? 255 : 140;

          
 29:       Uint8 g2 = ((stuff[(realLetter * 2) + 1] >> ((8 * (y + 4)) 

          
 30:         + (currCol % 8))) & 0x1) == 0x1 ? 255 : 140;

          
 31:       //
col
          
 32:       int x1
= xLet + (i << scale); 
          
 33:       int y1
= (y << scale); 
          
 34:       int x2
= xLet + (i << scale); 
          
 35:       int y2
= ((y + 4) << scale); 
          
 36: 

          
 37:       y1 = 125 + y1;//
* cos((double)sAngle*3.14/180.0);
          
 38:       y2 = 125 + y2;//
* cos((double)sAngle*3.14/180.0);
          
 39:       PSet(x1, y1, g1, 0, 0, screen);

          
 40:       PSet(x2, y2, g2, 0, 0, screen);

          
 41:     }

          
 42:   

          
 43:   }

          
 44: }

          
 45: 
        

That’s the entire source listing for the scroller. The horrible mess of bit-shifts and modulo translates the stored integer into a simple 0x1 or 0x0 for display.

The result looks like this:

Ubox – Enter the Hello World

Music was totally ripped from the Razor 1911 Chipdisk #3. I plan on changing that. The bouncing head is Bob Barker from Robot Chicken. Totally not posting until I find a way to not have to deal with DLL hell. The source is 463 lines long, including whitespace, written in C++ (so it’s no speed demon). I think for a hello-world sort of demo it’s not bad at all. Just need to watch more demos and get inspiration for this.

Did I mention this is only my second completely unmanaged C++ application that isn’t trivial? (The first was my Physics project for grade 12 – a GameBoy Advance ROM. That was some serious fun to work on.)

I’ve been on a cooking kick recently and have come up with a series of recipes that are tasty, cheap, and nutritious. Here’s one such dish.

• Skinless, boneless chicken breast
• Whole-wheat spaghetti noodles
• Red chili pepper flakes
• Garlic (either powder or fresh)
• Salt

Here’s how to prep:

1. Cook up the chicken breasts. Since I’ve got a Costco membership, I like to buy the bags of Kirkland frozen chicken breasts, as they yield 2kg worth. I’d recommend buying at least 400g worth of chicken breasts and cooking them all up at the same time. From frozen, bake in the oven for approx. 30 minutes at 400F.
2. At the same time, cook up the spaghetti noodles. As with the chicken, I like to cook a lot of it up at the same time so it’s ready to go when I need to throw a meal together quickly. Whole wheat noodles boiled should take 8-10 minutes.
3. After cooking the noodles, strain them. Once the excess water is removed, set aside and (optionally) let cool.
4. After cooking the chicken breasts, take one or two and cut into thin pieces, width-wise.
5. Get out the frying pan, put in some olive oil, and crank the heat to approximately medium (electric). When the oil is up to temperature, throw in some noodles, and the sliced up chicken.
6. Sprinkle on some red chili pepper flakes, garlic, and salt. Cook 3-5 minutes.
7. Plate, and serve.

I’ll post some pictures of this dish the next time I make it. Enjoy!

(Note: the directions to making this dish are a little vague, I know. It’s moreso a dish I threw together when I ran out of spaghetti sauce. It’s delicious though.)