JSEDLAK » C#

Korkboard 1.0.0.4

John Sedlak — Thu, 08 Jul 2010 11:20:55 +0000

Korkboard is a little tool I have been developing that enables a uniform method of storing multiple items on the clipboard. When Korkboard runs, it hooks into the clipboard chain and attempts to intercept messages as you use the Copy and Cut commands. It then stores the items on its own list so that they may be retrieved at a later time. It is important to note that Korkboard does not mess with the functionality of the clipboard. If you copy an item, the clipboard works as expected without any interruption or user required interception. Check it out, and let me know what you think!

Korkboard is written in WPF/.NET4 and uses ClickOnce to manage the installation and update processes.

Update: Added the Zip file for those having trouble using the ClickOnce method.

What is DMS?

John Sedlak — Fri, 12 Feb 2010 22:12:53 +0000

During the last semester I was taking a class on ASP.NET where we formed teams to write a website from scratch. The website was a “project manager” that would help users maintain projects, employees and customers. Given my experience with ASP.NET prior to the class, my team hit the ground in a full on sprint. We hit a wall when it came time to bind the site’s controls to the data behind it, in this case a Microsoft SQL database. The problems weren’t associated with a lack of knowledge but rather the gross disconnect between interfaces and the data with which they associate. It is easy to think that a textbox on a page can represent a name, but how that name is actually filled in can be the most complicated process.

This is just one instance of running into issues with data. How many times have you used a converter of some sort to scrub data or used a validator to make sure it can be stored? How many times have you written the same try-catch block for the SqlConnection class? How many times have you written a statement with “XmlDocument” or an instance somewhere in the middle? I have come to realize that there within the .NET Framework, there are many classes to get all the work done, but they aren’t really put together in a unified way. When you look at all the data-oriented classes (e.g. System.Xml.*, System.Data.*) you will find that there is no grand picture. For some reason the framework architects didn’t take a step back and see a possibility to unify the approach to reaching, converting, validating and consuming data.

So what is DMS? In short, the Data Management System prototype is a look into how possible it is to unify the approach to using data and whether or not it can make a developer’s life easier. The first step is to consider open architectures that are highly extensible and configurable. The current version of the DMS Prototype is focusing on just that by experimenting with converting runtime objects to and from XML. The important part isn’t the conversion; XML serialization has been done to death before. The important part to take away is that the serialization is being done in an abstracted manner. It is trying to gain as much information as possible from as little information as possible. The fewer attributes a developer has to use and the more generic they are, the easier life will be.

So what does a sample input object look like when using DMS? Something like the following class is perfectly suitable. Note that the only attribute being used here is the “NonSerialized” attribute. The others are sample attributes that may or may not be used at a later time.

^?View Code CSHARP

public class SampleObject
{
    public int PublicInteger = 6;
 
    [NotNullable(-1)]
    [UniqueIdentifier]
    [NumberConstraint(0, double.MaxValue)]
    public int Id { get; set; }
 
    [LengthConstraint(0, 50)]
    public string Title { get; set; }
 
    [NonSerialized]
    public int Secret = 3;
 
    public List<int> RawData { get; set; }
 
    public int[] Data = new int[] { 5, 6, 7, 8 };
 
    public SampleObject()
    {
        RawData = new List<int>();
        RawData.Add(32);
        RawData.Add(64);
    }
}

I can hear you asking about how the output looks like. XML is a weird format because it can be very simple and incredibly useless (a la the built-in XML Serializer), very powerful and very messy, or somewhere in between. If you haven’t already guessed, I am shooting for somewhere in between. One of the reasons behind creating DMS is to replace the built-in serializer. For now I will save that discussion for another post, but know that it is an important issue that needs to be addressed. The following is the previous class run through the current version of DMS.

^?View Code XML

 version="1.0" encoding="utf-16"?>
 
    xmlns:ns2="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
    xmlns:ns3="clr-namespace:System.Collections.Generic;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
    xmlns:ns1="clr-namespace:DMS.Driver;Assembly=DMS.Driver">
     Name="Id">5>
     Name="Title">Hello!>
     Type="System.Collections.Generic.List`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" Name="RawData">
        >32>
        >64>
    >
     Name="PublicInteger">6>
     Type="System.Int32[]" Name="Data">
      >5>
      >6>
      >7>
      >8>
    >
>

Overall, a little verbose but extremely powerful. So that is DMS in a nutshell. Would be happy to hear what you think of the idea and how the execution is going so far. You can comment here or use the Contact form.

FGF: It’s All About Abstraction

John Sedlak — Mon, 16 Nov 2009 15:41:58 +0000

One of the major themes present in the design of FGF is abstraction of functionality from its implementation. The major reason for this is because one of the major goals of FGF is to provide functionality without forcing developers into a corner. The idea is if the base of the framework is modular and open, the rest of the framework will fall into place very easily. So I begin the implementation of FGF by fixingimproving the XNA Framework’s Game class with an abstraction of its functionality. The reason for which will become apparent when the component classes are improved at a later time.

The important question to ask here is what can a game do? We can run a game, and exit a game but also add and remove components and services. Thus the IGame interface is born (within the FocusedGames.Xna project):

^?View Code CSHARP

using Microsoft.Xna.Framework;
 
namespace FocusedGames.Xna
{
    public interface IGame
    {
        void Run();
        void Exit();
 
        Vector2 ObjectToScreen(Vector2 objectVector);
        Vector2 ScreenToObject(Vector2 screenVector);
 
        GraphicsDeviceManager DeviceManager { get; }
 
        DisplayOrientation DisplayOrientation { get; set; }
        Vector2 DisplaySize { get; set; }
 
        bool IsLoaded { get; }
 
        float TargetFrameRate { get; set; }
 
        ModuleCollection Modules { get; }
    }
}

It should be immediately obvious that there are elements to this code that do not compile. I have added extra functionality due to the foresight of working with the Zune HD device and its re-orientating capabilities. Mainly the IGame interface (and any class that implements it) needs to provide a mechanism for dealing with how the screen and the objects within that screen are presented to the user. As for the last element, Modules, don’t worry about that for now as it will be covered in the next section.

Before implementing the IGame interface, the DisplayOrientation enumeration needs to be defined. You may have better terminology for all the options, I went with what came to my head initially and admit they aren’t the most descriptive choices. Remember that they have to describe the orientation on all the platforms and that the Zune HD’s landscape mode is much like the PC’s standard mode in terms of aspect ratio.

^?View Code CSHARP

namespace FocusedGames.Xna
{
    /// 
    /// Represents the orientation of the display.
    /// 
    public enum DisplayOrientation : byte
    {
        /// 
        /// Represents the standard orientation of the display. For Zune and Zune HD this is portrait mode.
        /// 
        Standard = 0,
 
        /// 
        /// Represents a 180 degree flip of the standard orientation.
        /// 
        Flipped = 1,
 
        /// 
        /// Represents a 90 degree rotation of the standard orientation. For the Zune and Zune HD this is landscape mode.
        /// 
        Rotated = 2,
 
        /// 
        /// Represents a -90 degree rotation of the standard orientation.
        /// 
        ReverseRotated = 3
    }
}

For now a dummy ModuleCollection class will do:

^?View Code CSHARP

namespace FocusedGames.Xna
{
    public class ModuleCollection
    {
    }
}

Finally we are ready to start implementing the IGame interface in a base class called Application so as not to confuse it with the XNA Framework’s Game class.

^?View Code CSHARP

using System;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace FocusedGames.Xna
{
    public class Application : Game, IGame
    {

The implementation will need a certain number of members to deal with the orientation of the screen. Specifically, a render target will be used to draw everything and then rotated it rather than rotating everything as they are drawn. I have found this makes for simpler code for end developers because rotations can get complicated fast.

^?View Code CSHARP

        private DisplayOrientation displayOrientation;
        private float displayRotation = 0f;
        private SpriteEffects displaySpriteEffects = SpriteEffects.None;
 
        private Vector2 orientedDisplaySize = new Vector2(800, 600);
        private Vector2 displaySize = new Vector2(800, 600);
 
        private SpriteBatch spriteBatch;
        private RenderTarget2D renderTarget;

Next comes the default constructor for the class which simply initializes several of the members for use later on. Here is where the basic defaults of any game are defined and you’ll note the Zune specific code for "saving" battery life.

^?View Code CSHARP

        public Application()
        {
            Modules = new ModuleCollection();
 
            DeviceManager = new GraphicsDeviceManager(this);
 
            ClearColor = Color.Black;
            DisplayOrientation = DisplayOrientation.Standard;
 
            Content.RootDirectory = "Content";
 
#if ZUNE
            // Frame rate is 30 fps by default for Zune.
            TargetElapsedTime = TimeSpan.FromSeconds(1 / 30.0);
#endif
        }

The implementation needs to load some content, set the display size up and then handle when the content needs to be unloaded. To do this the virtual methods provided by the XNA Framework work wonders. Just remember that when inheriting this class in the XNA game template to include calls to the base methods both in LoadContent and UnloadContent (they aren’t included by default – ugh!).

^?View Code CSHARP

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
 
            SetDisplaySize(displaySize);
 
            ResetRenderTarget();
 
            base.LoadContent();
 
            IsLoaded = true;
        }
 
        protected override void UnloadContent()
        {
            if(spriteBatch != null && !spriteBatch.IsDisposed)
                spriteBatch.Dispose();
 
            base.UnloadContent();
 
            IsLoaded = false;
        }

And now for the creation of the workhorse functions that maintain the orientation and display size and render target all in perfect harmony! The first one up is a function that is called to change the orientation of the display at any time. There are a couple ways of going about this; I have found using the sprite effects to be simple and effective. It is important to note that at the end of the function the render target is reset if the game has been loaded. If you fail to do this, things will get funky!

^?View Code CSHARP

        protected virtual void SetDisplayOrientation(DisplayOrientation newOrientation)
        {
            // Removed so this method can act as a reset as well
            // if (newOrientation == displayOrientation) return;
 
            displayOrientation = newOrientation;
 
            // TODO: Handle orientations
            switch (displayOrientation)
            {
                case DisplayOrientation.Standard:
                    orientedDisplaySize = displaySize;
                    displayRotation = 0;
                    displaySpriteEffects = SpriteEffects.None;
                    break;
                case DisplayOrientation.Flipped:
                    orientedDisplaySize = displaySize;
                    displayRotation = 0;
                    displaySpriteEffects = SpriteEffects.FlipVertically | SpriteEffects.FlipHorizontally;
                    break;
                case DisplayOrientation.Rotated:
                    orientedDisplaySize.X = displaySize.Y;
                    orientedDisplaySize.Y = displaySize.X;
                    displayRotation = MathHelper.PiOver2;
                    displaySpriteEffects = SpriteEffects.None;
                    break;
                case DisplayOrientation.ReverseRotated:
                    orientedDisplaySize.X = displaySize.Y;
                    orientedDisplaySize.Y = displaySize.X;
                    displayRotation = MathHelper.PiOver2;
                    displaySpriteEffects = SpriteEffects.FlipVertically | SpriteEffects.FlipHorizontally; //SpriteEffects.FlipHorizontally;
                    break;
            }
 
            if(IsLoaded)
                ResetRenderTarget();
        }

The following method changes the display size of the screen and calls the previous method, SetDisplayOrientation, because as the screen size is changed, everything else is affected.

^?View Code CSHARP

        protected virtual void SetDisplaySize(Vector2 newSize)
        {
            // Removed so this method can act as a reset as well
            // if (newSize == displaySize) return;
 
            displaySize = newSize;
            orientedDisplaySize = newSize;
 
            // Reset the backbuffer
            DeviceManager.PreferredBackBufferWidth = (int)displaySize.X;
            DeviceManager.PreferredBackBufferHeight = (int)displaySize.Y;
 
            // If we already loaded, apply the changed
            if (IsLoaded)
                DeviceManager.ApplyChanges();
 
            // Reset the orientation details
            SetDisplayOrientation(displayOrientation);
        }

And finally a method that resets the render target. In the future, the stub for Windows / Xbox 360 must be filled in with a robust RT creation method.

^?View Code CSHARP

        private void ResetRenderTarget()
        {
#if ZUNE
            if (renderTarget != null && !renderTarget.IsDisposed)
                renderTarget.Dispose();
 
            renderTarget = new RenderTarget2D(GraphicsDevice, (int)orientedDisplaySize.X, (int)orientedDisplaySize.Y, 1, SurfaceFormat.Color);
#else
            // TODO: Do some RT work here for Windows / Xbox 360
#endif
        }

But really that is only half of the implementation! Now that we have the members setup for drawing an orientated screen, the drawing actually has to happen. This code comes your way from Nick Gravelyn with some minor modifications. The first method, ClearGraphicsDevice, is provided as a virtual member because it should be changed by end-developers when complex clears need to occur. This is done in lieu of many more options and fields on the IGame interface.

^?View Code CSHARP

        /// 
        /// Clears the GraphicsDevice.
        /// 
        protected virtual void ClearGraphicsDevice()
        {
            GraphicsDevice.Clear(ClearColor);
        }

In the BeginDraw method, the device needs to be cleared and the render target needs to be setup in some cases. In other cases, clearing the device is enough and the function is short circuited.

^?View Code CSHARP

        protected override bool BeginDraw()
        {
            if (base.BeginDraw())
            {
                if (DisplayOrientation == DisplayOrientation.Standard)
                {
                    ClearGraphicsDevice();
                    return true;
                }
 
                if (renderTarget == null || renderTarget.IsDisposed)
                {
                    ClearGraphicsDevice();
                    return false;
                }
 
                GraphicsDevice.SetRenderTarget(0, renderTarget);
 
                ClearGraphicsDevice();
 
                GraphicsDevice.Viewport = new Viewport
                {
                    X = 0,
                    Y = 0,
                    Width = (int)orientedDisplaySize.X,
                    Height = (int)orientedDisplaySize.Y,
                    MinDepth = GraphicsDevice.Viewport.MinDepth,
                    MaxDepth = GraphicsDevice.Viewport.MaxDepth
                };
 
                return true;
            }
 
            return false;
        }

And last but certainly not least, the EndDraw and supporting methods need to clean up, present the render target and then draw any overlays before presenting to the screen. Here is where the real rotation magic occurs.

^?View Code CSHARP

        protected override void EndDraw()
        {
            if (!IsLoaded)
                return;
 
            if (DisplayOrientation == DisplayOrientation.Standard ||
                (renderTarget == null || renderTarget.IsDisposed))
            {
                //base.EndDraw();
                FinalizeDraw();
 
                return;
            }
 
            GraphicsDevice.SetRenderTarget(0, null);
            GraphicsDevice.Viewport = new Viewport
            {
                X = 0,
                Y = 0,
                Width = (int)displaySize.X,
                Height = (int)displaySize.Y,
                MinDepth = GraphicsDevice.Viewport.MinDepth,
                MaxDepth = GraphicsDevice.Viewport.MaxDepth
            };
 
            spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.SaveState);
 
            spriteBatch.Draw(
                renderTarget.GetTexture(),
                displaySize / 2,
                null,
                Color.White,
                DisplayRotation,
                orientedDisplaySize / 2,
                1f,
                DisplaySpriteEffects,
                0
            );
 
            spriteBatch.End();
 
            //base.EndDraw();
            FinalizeDraw();
        }
 
        private void FinalizeDraw()
        {
            DrawOverlay();
 
            base.EndDraw();
        }
 
        /// 
        /// Draw's unrotated graphics.
        /// 
        protected virtual void DrawOverlay()
        {
        }

And before we can really call this implementation done (for now anyways), the various properties used need to be defined. These are given to you a la shotgun because they are straight forward and self explanatory.

^?View Code CSHARP

        /// 
        /// Gets screen coordinates from object coordinates.
        /// 
        /// The object's coordinates.
        /// Coordinates in screen space.
        public Vector2 ObjectToScreen(Vector2 objectVector)
        {
            return new Vector2(displaySize.X - objectVector.Y, objectVector.X);
        }
 
        /// 
        /// Gets object coordinates from screen coordinates.
        /// 
        /// The coordinates in screen space.
        /// Coordinates in object space.
        public Vector2 ScreenToObject(Vector2 screenVector)
        {
            return new Vector2(screenVector.Y, displaySize.X - screenVector.X);
        }
 
        public GraphicsDeviceManager DeviceManager { get; private set; }
 
        /// 
        /// Gets or Sets the orientation of the display.
        /// 
        public DisplayOrientation DisplayOrientation
        {
            get { return displayOrientation; }
            set { SetDisplayOrientation(value); }
        }
 
        /// 
        /// Gets or Sets the size of the display.
        /// 
        public Vector2 DisplaySize
        {
            get { return displaySize; }
            set { SetDisplaySize(value); }
        }
 
        /// 
        /// Gets the rotation of the display.
        /// 
        /// 
        public float DisplayRotation { get { return displayRotation; } }
 
        /// 
        /// Gets the SpriteEffects for the display's render target.
        /// 
        /// 
        public SpriteEffects DisplaySpriteEffects { get { return displaySpriteEffects; } }
 
        /// 
        /// Gets whether or not the application has been loaded.
        /// 
        public bool IsLoaded { get; private set; }
 
        /// 
        /// Gets or Sets the clear color of the graphics device.
        /// 
        protected Color ClearColor { get; set; }
 
        /// 
        /// Gets the SpriteBatch used to draw the main render target.
        /// 
        protected SpriteBatch SpriteBatch { get { return spriteBatch; } }
 
        /// 
        /// Gets or Sets the target frame rate for the underlying loop code.
        /// 
        public float TargetFrameRate
        {
            get { return 1 / (float)TargetElapsedTime.TotalSeconds; }
            set
            {
                TargetElapsedTime = TimeSpan.FromSeconds(1 / value);
            }
        }
 
        public ModuleCollection Modules { get; private set; }
    }
}

FGF: Getting Started

John Sedlak — Thu, 05 Nov 2009 15:08:52 +0000

This series is devoted to the design and development of my framework, FGF (Focused Games Framework), and aims to cover topics like async content management, WCF services, and many more. In this first article, I cover how to setup Visual Studio 2008 for coding the framework. It is important to understand that I will be using Visual Studio Team System 2008 and thus may have features that are not available in the Express edition. It is possible to get around many of these or ignore them completely, however, so not having Team System does not mean developing FGF is impossible.

The first step is to open up the IDE and create our solution. When starting a large solution such as the one for FGF, I find it useful to create a Blank Solution so that the solution’s name can be different than that of the first project. Again, this can be worked around in Express as well as other versions of the editor.

The next step is an obvious one: add the first project. The design of FGF is based on a hierarchy of libraries much like the .NET Framework. Whereas libraries depend on the System DLL and mscorlib, FGF libraries can all depend on the core project, FocusedGames. To enable some cross-platform awesomeness down the road, we make this project an XNA library and then remove the references to the XNA Framework. Remember that FGF is not just an XNA framework and should support situations where XNA is not installed. You can see the cleaned project in the below screenshot.

After creating some copy projects for the Zune and the Xbox 360, repeat the process for a new project, FocusedGames.Xna. At this point you may find it nice to move the platform specific projects into platform specific Solution Folders. This is one of the features of Visual Studio I wish was present in the Express Edition, but unfortunately it was left out. The really nice part of Solution Folders is that it does not physically move the project files. Rather it simply organizes them in a virtual fashion.

Regardless, the last step is to setup the output directory. Personally, I like having the projects all push to the same bin folder so I can copy them with a Powershell script very easily. To do this, go into each project’s properties and change the output directory to something like “..\Bin\whatever was here>” and remember to change it for both Debug and Release.

Finally we are ready to start coding!

Utilizing XSLT with FGF

John Sedlak — Mon, 21 Sep 2009 21:24:59 +0000

After developing with the Sitecore CMS for a couple of months I have seen what XSLT can offer in terms of a powerful web technology. I decided early on, before using Sitecore, that Vodka 2.0 would have to support XSL transforms since the content is stored as XML. The following is a sample of how to work with XML and XSLT in the second version of the Focused Games Framework (FGF 2.0).

While the XSLT code can go pretty much anywhere in the ASP.NET pipeline, for now I have put it in my main Controller. Note that this code is not final, I will be looking into a better way to streamline the content retrieval process.

^?View Code CSHARP

public class ContentController : Controller
{
    public ActionResult Get(string uri)
    {
        Content content = GetContent(uri, -1);
        Content template = GetContent(content.TemplateId, -1);

Next the XslTransformer class is instantiated and a test extension is added. Extensions can be simple or complext .NET classes. Again I plan to streamline this process and support loading from the web.config file.

^?View Code CSHARP

        XslTransformer transformer = new XslTransformer(GetDocument);
        transformer.AddExtension(
            new XsltExtension
            {
                Namespace = "http://focusedgames.com/vodka",
                Provider = new VodkaXslExtensions()
            }
        );
 
        ViewData["Content"] = transformer.Transform(uri, template.Meta.Uri);
 
        return View("Get", "~/Themes/FGDN/Theme.master");
    }

When the Transform method is invoked, the transformer attempts to load documents through a callback. This process will definitely be streamlined so that the re-implementation of the following method isn’t required. The callback method loads the content straight from the database through an SqlContentProvider object. Not much has really changed here since Vodka 1.0 except for the addition of support for both languages and versioning.

^?View Code CSHARP

    public Content GetContent(string uri, int parent)
    {
        SqlContentProvider scp = new SqlContentProvider();
 
        NameValueCollection parameters = new NameValueCollection();
        parameters.Add(SqlContentProvider.ConnectionStringParameterName, connectionString);
 
        scp.Initialize(parameters);
 
        Content content = scp.GetContent(uri.ToLower());
 
        return content;
    }
 
    private XPathDocument GetDocument(Uri uri)
    {
        Content content = GetContent(uri.OriginalString, -1);
 
        XPathDocument document = new XPathDocument(new StringReader(content.Xml));
 
        return document;
    }
}

And finally the simple extension object:

^?View Code CSHARP

public class VodkaXslExtensions
{
    public string GetDate()
    {
        return DateTime.Now.ToString();
    }
}

So what does this produce exactly? Well it takes the following XML…

^?View Code HTML



    Home
    
        This website is still under construction, please check back soon.
        Thank you,
        John Sedlak

And uses the following XSLT file (stored in the Vodka Database)…

^?View Code HTML

And produces the following HTML…

^?View Code HTML

1
2
3

Home

This website is still under construction, please check back soon.Thank you,John Sedlak

9/21/2009 5:23:04 PM

Sitecore Tip: Stripping HTML Tags

John Sedlak — Fri, 14 Aug 2009 13:22:29 +0000

Here is a quick and incredibly useful tip for using the Sitecore API. Recently I was looking for an easy way to strip HTML tags from a string (in C# code) and Alex de Groot responded to the call. Turns out that the process is insanely painless.

^?View Code CSHARP

1	Sitecore.StringUtil.RemoveTags(string) : string

A Spark of Genius?

John Sedlak — Wed, 10 Dec 2008 01:44:26 +0000

Knowing how frameworks are designed and developed definately has its benefits. Awhile ago I spent some time looking into how DependencyObject and DependencyProperty work in WPF. Essentially, many of the properties are not simple properties but rather facades for method invocations.

Fast forward to today when I was working on Versionator, an application I am writing to help me manage my many projects’ versions. The problem is that project information files (AssemblyInfo.cs) are not straight forward in terms of parsing. They are merely text files, awkward and malformed code files in fact. To be able to support many properties so easily, I came up with a scheme to parse, manage and save the projects’ properties in the file.

What I do is parse the properties, extracting the data and storing it in a dictionary as “old values.” At the same time I create a copy of the values in a “current values” dictionary. As new values come in, I channel them through properties, then Get and Set methods which access the “current values” dictionary. When it comes time to save I have to do some management of the data based on whether or not the property was empty, non-existant or is being changed to empty. It is simple to say that it would have taken me a lot longer if I had not taken a look at WPF. So was it a spark of genius? Or just plain old learnedness?

The Code (Beware of its massive length):

^?View Code CSHARP

using System;
using System.Collections.Generic;
using System.IO;
 
namespace FocusedGames.Versionator.Data
{
    public class ProjectInfo
    {
        public enum Properties : ushort
        {
            Title = 0,
            Description = 1,
            Company = 2,
            Product = 3,
            Copyright = 4,
            Trademark = 5,
            AssemblyVersion = 6,
            FileVersion = 7,
            Guid = 8
        }
 
        private readonly string[] lookups = new [] { "AssemblyTitle", "AssemblyDescription", "AssemblyCompany", "AssemblyProduct", "AssemblyCopyright", "AssemblyTrademark", "AssemblyVersion", "AssemblyFileVersion", "Guid" };
        private readonly Dictionary<ushort, string> propertyValues = new Dictionary<ushort, string>();
        private readonly Dictionary<ushort, string> oldValues = new Dictionary<ushort, string>();
 
        public static ProjectInfo FromFile(string filename)
        {
            return new ProjectInfo(filename);
        }
 
        public ProjectInfo()
        {
            Array enumValues = Enum.GetValues(typeof (Properties));
 
            foreach(ushort prop in enumValues)
            {
                propertyValues.Add(prop, string.Empty);
                oldValues.Add(prop, string.Empty);
            }
        }
 
        public ProjectInfo(string filename)
            : this()
        {
            Load(filename);
        }
 
        #region Getting and Setting Project Properties
        protected void SetProperty(Properties prop, string value)
        {
            propertyValues[(ushort) prop] = value;
        }
 
        protected string GetProperty(Properties prop)
        {
            string newValue = propertyValues[(ushort) prop];
 
            if(string.IsNullOrEmpty(newValue))
                return oldValues[(ushort) prop];
 
            return newValue;
        }
        #endregion
 
        #region Loading and Saving
        public void Load(string filename)
        {
            Filename = filename;
 
            string[] lines = File.ReadAllLines(Filename);
 
            Array enumValues = Enum.GetValues(typeof (Properties));
 
            foreach(ushort prop in enumValues)
            {
                Load(lines, prop);
            }
        }
 
        private void Load(string[] lines, ushort lookup)
        {
            for(int i = 0; i < lines.Length; i++)
            {
                string currentLine = lines[i];
                string searchTerm = lookups[lookup];
 
                // Get the first index of the search term
                int firstIndex = currentLine.IndexOf(searchTerm);
 
                // The property wasn't found, continue
                // through the file.
                if(firstIndex == -1)
                    continue;
 
                // Now we need to extract the data out of the string!
                string data = currentLine.Substring(firstIndex + searchTerm.Length).TrimFront("\"").TrimBack("\"");
 
                oldValues[lookup] = data;
                propertyValues[lookup] = data;
            }
        }
 
        public void Save()
        {
            string[] lines = File.ReadAllLines(Filename);
 
            Array enumValues = Enum.GetValues(typeof(Properties));
 
            foreach (ushort prop in enumValues)
                Save(lines, prop);
 
            StreamWriter sw = new StreamWriter(Filename, false);
 
            for(int i = 0; i < lines.Length; i++)
                sw.WriteLine(lines[i]);
 
            sw.Close();
        }
 
        private void Save(string[] lines, ushort prop)
        {
            for (int i = 0; i < lines.Length; i++)
            {
                string currentLine = lines[i];
                string searchTerm = lookups[prop];
 
                // Get the first index of the search term
                int firstIndex = currentLine.IndexOf(searchTerm);
 
                // The property wasn't found, continue
                // through the file.
                if (firstIndex == -1)
                    continue;
 
                string oldValueLocal = oldValues[prop];
                string newValueLocal = propertyValues[prop];
 
                // If the old value didn't exist, we can adjust the 
                // replacement mechanism to remove the "" and add
                // them back in.
                if (string.IsNullOrEmpty(oldValueLocal))
                {
                    oldValueLocal = "\"\"";
                    newValueLocal = string.Format("\"{0}\"", newValueLocal);
                }
 
                // We also need to catch people emptying strings out.
                // To do this we adjust the saving mechanism the same way.
                if(string.IsNullOrEmpty(newValueLocal))
                {
                    oldValueLocal = string.Format("\"{0}\"", oldValueLocal);
                    newValueLocal = "\"\"";
                }
 
                // Replace the old value with the new value
                if (!string.IsNullOrEmpty(newValueLocal))
                        lines[i] = lines[i].Replace(oldValueLocal, newValueLocal);
            }
        }
        #endregion
 
        public string Filename { get; private set; }
 
        public string AssemblyVersion
        {
            get { return GetProperty(Properties.AssemblyVersion); }
            set { SetProperty(Properties.AssemblyVersion, value); }
        }
 
        public string FileVersion
        {
            get { return GetProperty(Properties.FileVersion); }
            set { SetProperty(Properties.FileVersion, value); }
        }
 
        public string Title 
        {
            get { return GetProperty(Properties.Title); }
            set { SetProperty(Properties.Title, value); }
        }
 
        public string Description
        {
            get { return GetProperty(Properties.Description); }
            set { SetProperty(Properties.Description, value); }
        }
 
        public string Company
        {
            get { return GetProperty(Properties.Company); }
            set { SetProperty(Properties.Company, value); }
        }
 
        public string Product 
        {
            get { return GetProperty(Properties.Product); }
            set { SetProperty(Properties.Product, value); }
        }
 
        public string Copyright
        {
            get { return GetProperty(Properties.Copyright); }
            set { SetProperty(Properties.Copyright, value); }
        }
 
        public string Trademark
        {
            get { return GetProperty(Properties.Trademark); }
            set { SetProperty(Properties.Trademark, value); }
        }
 
        public string Guid
        {
            get { return GetProperty(Properties.Guid); }
            set { SetProperty(Properties.Guid, value); }
        }
    }
}

P.S. The code is not done, is not even close to being efficient or functionally complete. But it works!

Tackling The Problem

John Sedlak — Wed, 03 Dec 2008 13:08:31 +0000

Tackling the problem in the previous post I have decided to rely on providing more options than necessary. I have to remember that because Vodka is not client software, I have to write it as if the client software will be as simple as possible. The goal of Vodka is to give developers a way of setting up a software based CMS with great ease.

To do this, I have built in services that can be implemented and exposed via WCF as well as built in implementations of these services. If you had the binaries for Vodka, you could reference FocusedGames.Vodka.Services, create a class in a Service project and inherit from ContentService or MembershipService. After deploying the project, you can treat it like any other WCF service reference.

The original question dealt with translation services however, is it a client or server responsibility? You would generally make it client side because you may wish to get a different template for the content or change how translation is done. This is on par with most CMS software installs out there but there is a problem. Templates in the Vodka backend are treated as standard items of content. It then would require two calls to the service: one for the template and one for the content. You would also have to know how the template is extracted from the content item. This is a bad idea as it increases server load unecessarily.

The answer is simple: abstract it and keep it server side. The idea here is that the developers can plugin their own template provider into the service when setting it up. This will allow them to point to another service, a local directory or hardcoded templates. If no plugin is used, the service will continue on its standard course, grabbing the template from the standard content data store.

You may be asking why you would ever want to use a custom provider to point to a second service. Let’s say you have a ton of websites that you all want to look the same. For instance Microsoft may have microsoft.com, msdn.microsoft.com, creators.xna.com, xbox.com, et cetera and may want them to all use the same templates for items. They could use a provider to point to a single template service removing the need to change 5+ templates on 5+ servers.

Problems With Vodka

John Sedlak — Mon, 01 Dec 2008 13:08:37 +0000

The Vodka Content Management System is a service based, multitier setup with the clients getting access to all content and member information via services. In turn, the services communicate with each other as well as their respective data stores. One of the goals of designing Vodka is to implement objects in a way that is easily extendable. To accomplish this, all content is managed in terms of the text data (XML) and its meta data (title, author, date stamps, et al).

The problem is how this data is transformed into its two main uses: HTML and .NET Objects. The question is where these transformations take place. In order to transform an XML file into HTML, the code needs access to an XSL file. The problem with this is that it too, is treated as a piece of content. It is regulated in exactly the same way with the same level of security. Thus it can be seen that this service should remain on the server. This is where it currently sits, so what is the problem?

The problem remains that it shouldn’t be a server side operation! That is slow! It requires more implementations than necessary and furthermore it builds a bad dependency on the server for specific implementation.

Screenshot of the Day

John Sedlak — Wed, 05 Nov 2008 17:02:25 +0000

This is from the most recent build of FGF:

Yes, it is my own implementation of the Aero style of windows done in XNA. What does this mean? Well I have decided that although the simple way of doing a menu system in games is fine for simple situations, I want something more powerful and prettier to look at. Thus I have started working on a new UI library for Thrust that is based on Aero and similar interfaces. I am doing it in a fully customizable but lightweight manner and working on Xbox 360 compatibility.