I’ve always wanted a program that would allow me have a command line that I could slide in and out of view as needed like the console from Quake. I never could find one and so I finally got decided to write a tool myself. A picture is below and the source code is on GitHub.
I’m not putting a download here as I don’t consider this finished just yet.
I originally got the idea for Snowball after working with the Xna Framework. The Xna Framework is a good piece of software for what it is but there are some things about which I just do not agree with:
Xna was designed as an abstraction layer for all the 3 platforms mentioned in the last point, so that one is somewhat understandable. I don’t want to write games for my XBox right now though, so why should things like drawing lines not be available to me?
With these points in mind I started working on Snowball. It’s designed to be an Xna like framework for making 2D games. It uses SlimDX on the backend, but that is completely abstracted away from consumers of the framework. What I want to do is design the API so that the backend can be swapped out somewhat painlessly.
I still have a ways to go before I will consider it a version 1.0 release. As of this writing, I’m transitioning to more of a ContentLoader class style for loading your game’s content. Any resource type from within the framework can be loaded by hand if you want, the ContentLoader class will just make it easier. After that I have a few other features like GamePad and Music which I would like to implement before saying I have a Beta type release.
The future after that is up in the air. I would love to try and have different implementations of the API for Xna and/or OpenTK.
I recommend for anyone who is interested as to why an API designer choose to implement the API in the way they did to try it for themselves. I have learned many things from this project including why certain design decisions were made by the Xna Framework team.
Just a quick post to hopefully save anyone who finds this some time. If you need to convert a datetime value from a WMI query to a native DateTime object in C#, you can use the method ToDateTime() on the ManagementDateTimeConverter class.
ManagementDateTimeConverter.ToDateTime(dmtfDate);
I needed a tool that would copy the contents of a Zune playlist to a given directory. I did a bit of googling and I couldn’t find anything, so like any good nerd I wrote a tool that did.
The format of Zune playlists is a simple XML format known as SMIL. I think Windows Media Player also stores playlists in this format but I haven’t confirmed that yet.
I wrote the tool very quickly and have only tested it on my machine with my test data, but I’ll provide the source if you’d like to modify for yourself. The source is C#.
The other day I started an open source project for an IoC Container I call Component Glue. It’s in a toy / learning tool status right now and I don’t know how far I actually want to take the project. More to come though.
By extending your Service Container class, a very basic version of dependency injection can be implemented. We’ll implement two forms of dependency injection: constructor and property injection.
I decided to add progress bar to the Windows 7 Taskbar in my Timer app.
I started by downloading and compiling the Windows API Code Pack in Release mode. I then added a reference to the Microsoft.WindowsAPICodePack.dll and Microsoft.WindowsAPICodePack.Shell.dll files to the project. After that add the lines:
using Microsoft.WindowsAPICodePack.Taskbar;
to your using statements. When the clock starts running I create the progress bar in the taskbar with:
// Initialize progress bar
if(TaskbarManager.IsPlatformSupported)
{
TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.Normal);
TaskbarManager.Instance.SetProgressValue(0, (int)this.totalTime.TotalSeconds, this.Handle);
}
to stop the progress bar:
// Stop progress bar if(TaskbarManager.IsPlatformSupported) TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.NoProgress);
and finally to update the progress bar on each tick:
// Update progress bar if(TaskbarManager.IsPlatformSupported) TaskbarManager.Instance.SetProgressValue((int)this.totalTime.TotalSeconds - (int)this.time.TotalSeconds, (int)this.totalTime.TotalSeconds, this.Handle);
Just a quick code snippet which adds an extension method for drawing Rectangles to SpriteBatch:
public static class SpriteBatchHelper
{
static Texture2D pixel;
private static void LoadPixel(GraphicsDevice graphicsDevice)
{
if(pixel == null)
{
pixel = new Texture2D(graphicsDevice, 1, 1);
pixel.SetData<Color>(new Color[] { Color.White });
}
}
public static void DrawRectangle(this SpriteBatch spriteBatch, Rectangle rectangle, Color color)
{
LoadPixel(spriteBatch.GraphicsDevice);
spriteBatch.Draw(pixel, rectangle, color);
}
}
Normally I use extension methods in C# to extend a library that I did not write and therefore I have no control over. There are situations where it makes sense to use extension methods for a library that you yourself are writing.
For example, when you have interfaces in your library. You want to keep the number of methods in that interface as low as possible so that classes implementing the interface don’t have to do a lot of heavy lifting. This means cutting out methods in an interface that are for the most part just syntactic sugar for another method in the interface.
public interface IServiceContainer
{
void AddService(Type type, Object provider);
object GetService(Type type);
}
public static class IServiceContainerExtensions
{
public static void AddService<T>(this IServiceContainer services, object provider)
{
services.AddService(typeof(T), provider);
}
public static T GetService<T>(this IServiceContainer services) where T : class
{
return services.GetService(typeof(T)) as T;
}
public static T GetRequiredService<T>(this IServiceContainer services) where T : class
{
T service = services.GetService(typeof(T)) as T;
if(service == null)
throw new ServiceNotFoundException(typeof(T));
return service;
}
}
All of the methods in IServiceContainerExtensions are just helper methods for method in IServiceContainer. By making them extension methods in our own library though, we’ve made the barrier to entry lower. Other people can implement the interface and in a sense “inherit” the helper methods as well.