TWith2Sugars

Photo

Tue, 09 Aug 2011 08:25:00 +0100

Automatypewriter, an arduino project

Wed, 03 Nov 2010 16:16:21 +0000

Automatypewriter, an arduino project

Inception explained for Mac Users Image...

Wed, 25 Aug 2010 10:20:49 +0100

Inception explained for Mac Users

Image from:

http://twitpic.com/2hee34

graphicly: ianbrooks: geek-art: 8bitmonster: dr-8bit: The...

Tue, 13 Jul 2010 17:38:54 +0100

graphicly:

ianbrooks:

geek-art: 8bitmonster: dr-8bit:

The Evolution of Gaming

I can’t wait for Mind Control to come out.

Hey Hey 16K!

Wed, 26 May 2010 14:25:14 +0100

Hey Hey 16K!

WPF 4 & Spellchecking

Mon, 12 Apr 2010 19:04:02 +0100

Using WPF 4?

Want spell checking on your textbox?

BAM: SpellCheck.IsEnabled=”True”

I love it!

Single instance app in WPF 4 with argument passing.

Tue, 30 Mar 2010 09:09:00 +0100

I was building a WPF app that required the use of JumpLists; the thing with JumpLists is that it calls your app’s exe with an argument which in turn creates a new instance of your app.

After a quick bit of googling I found a link [now dead] some code that restricts an app to a signle instance by using a mutex and passes the command argument supplied via named pipes.

Only portions of the code was recoverable, the rest I created my self.

Note that the code uses the .Net 4 Tasks, this can be replaced with threads if you want to use it in .Net 3.5. This also only passes the first argument through but can be easily changed to pass multiple.

namespace Your.App
{
  using System;
  using System.IO;
  using System.IO.Pipes;
  using System.Threading;
  using System.Threading.Tasks;

  public class SingleInstance : IDisposable
  {
    private readonly bool ownsMutex;
    private Mutex mutex;
    private Guid identifier;

    /// 
    /// Occurs when [arguments received].
    /// 
    public event EventHandler> ArgumentsReceived;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The id.
    public SingleInstance(Guid id)
    {
      this.identifier = id;
      mutex = new Mutex(true, identifier.ToString(), out ownsMutex);
    }

    /// 
    /// Gets a value indicating whether this instance is first instance.
    /// 
    /// 
    /// 	true if this instance is first instance; otherwise, false.
    /// 
    public bool IsFirstInstance
    {
      get
      {
        return ownsMutex;
      }
    }

    /// 
    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
    /// 
    public void Dispose()
    {
      if (mutex != null && ownsMutex)
      {
        mutex.ReleaseMutex();
        mutex = null;
      }
    }

    /// 
    /// Passes the arguments to first instance.
    /// 
    /// The argument.
    public void PassArgumentsToFirstInstance(string argument)
    {
      using (var client = new NamedPipeClientStream(identifier.ToString()))
      using (var writer = new StreamWriter(client))
      {
        client.Connect(200);
        writer.WriteLine(argument);
      }
    }

    /// 
    /// Listens for arguments from successive instances.
    /// 
    public void ListenForArgumentsFromSuccessiveInstances()
    {
      Task.Factory.StartNew(() =>
                              {

                                using (var server = new NamedPipeServerStream(identifier.ToString()))
                                using (var reader = new StreamReader(server))
                                {
                                  while (true)
                                  {
                                    server.WaitForConnection();

                                    var argument = string.Empty;
                                    while (server.IsConnected)
                                    {
                                      argument += reader.ReadLine();
                                    }

                                    CallOnArgumentsReceived(argument);
                                    server.Disconnect();
                                  }
                                }
                              });
    }

    /// 
    /// Calls the on arguments received.
    /// 
    /// The state.
    public void CallOnArgumentsReceived(object state)
    {
      if (ArgumentsReceived != null)
      {
        if (state == null)
        {
          state = string.Empty;
        }

        ArgumentsReceived(this, new GenericEventArgs() { Data = state.ToString() });
      }
    }
  }
}

Here is the Generic Event Args class

namespace Your.App
{
  using System;

  public class GenericEventArgs : EventArgs
  {
    /// 
    /// Gets or sets the data.
    /// 
    /// The data.
    public TEventDataType Data { get; set; }
  }
}

To use this class create an instance with a GUID for your app like so:

private static readonly SingleInstance SingleInstance = new SingleInstance(new Guid("24D910A1-1F03-44BA-85A0-BE7BC2655FFE"));

Then on Application_Startup run your logic for it

private void Application_Startup(object sender, StartupEventArgs e)
{
  if (SingleInstance.IsFirstInstance)
  {
    SingleInstance.ArgumentsReceived += SingleInstanceParameter;
    SingleInstance.ListenForArgumentsFromSuccessiveInstances();
	// Do your other app logic
  }
  else
  {
    // if there is an argument available, fire it
    if (e.Args.Length > 0)
    {
      SingleInstance.PassArgumentsToFirstInstance(e.Args[0]);
    }
	
    Environment.Exit(0);
  }
}

static void SingleInstanceParameter(object sender, GenericEventArgs e)
{
  // Inform app of new arguments
}

Brilliant….

Tue, 16 Mar 2010 10:19:54 +0000

Brilliant….

robnixon: graphicly: Thanks to Microsoft BizSpark One, here’s...

Tue, 16 Mar 2010 08:14:10 +0000

robnixon:

graphicly:

Thanks to Microsoft BizSpark One, here’s a demo of Graphic.ly for Win 7 Mobile from Microsoft Mix 2010!

I’m with Kevin, you can almost see Tony’s nose hairs!

No question...

Thu, 11 Mar 2010 17:15:00 +0000

No question really….

source: http://thisisindexed.com/2010/03/fantasy-league/

Want the directory of a .Net app?

Tue, 23 Feb 2010 10:58:41 +0000

Then use this line:

AppDomain.CurrentDomain.BaseDirectory

likes 28 Weeks Later on Boxee

Wed, 17 Feb 2010 19:09:18 +0000

likes 28 Weeks Later on Boxee

Xml Serialisation (Serialization) in C#

Wed, 17 Feb 2010 09:01:00 +0000

Xml Serialisation (Serialization) in C#:

One thing I absolutely hate doing is reading xml, it bores me to bits. So to make this dreadful task a little more easier I use a nice little extension function that I found (and improved; then put up on stackoverflow). If you mark a class with the XmlSerialization attributes (XmlRoot/XmlElement) you can quickly take an xml string and turn it in to an object.

ASP.Net Pager Control

Wed, 17 Feb 2010 08:55:46 +0000

ASP.Net Pager Control:

I built this quite a while ago - some one might find it useful.

Find the transparent pixels in an image - WPF

Tue, 16 Feb 2010 14:06:00 +0000

The other day I had to create an image element that contained a png with transparent sections and have it display a hand cursor when the mouse was over the opaque sections.

The first thing I tried (and failed) was to have an image element with the cursor property set to “Hand” like so:

That obviously never worked so I was forced to look at each individual pixel and see if it was transparent. What I ended up with was a function that generated a bunch of coordinates.

This is that function:

private static Dictionary FindTransparentPixelCoordinates(BitmapSource source)
{
  var points = new Dictionary();

  // Convert the source if the pixel format is not what we expect
  if (source.Format != PixelFormats.Bgra32)
  {
    source = new FormatConvertedBitmap(source, PixelFormats.Bgra32, null, 0);
  }

  int width = source.PixelWidth;
  int height = source.PixelHeight;
  var bytes = new byte[width * height * 4];

  source.CopyPixels(bytes, width * 4, 0);

  var position = 0;

  for (var y = 0; y < height; y++)
  {
    for (var x = 0; x < width; x++)
    {
      var byteOffset = position;

      // The pixel format is stored as 32-bits (4 bytes) with the last byte being the alpha

      if (bytes[byteOffset + 3] == 0)
      {
        points.Add(new Point(x, y), null);
      }

      position += 4;
    }
  }

  return points;
}