bc-programming » General Computing

WordPress, Sourcecode, and escaping

BC_Programming — Sun, 06 May 2012 05:41:53 +0000

Every single time I write a post that contains source code, it’s a bloody struggle.

Take my previous “snippets” entry.

Normally, I draft it and plan it in advance, and use Editpad Pro on my windows machine to write it out. Now, in a ideal universe where stuff works properly, I would be able to just paste the code in without putting dumbass escapes- that’s what the CMS is supposed to do, manage my content- but no such luck. So, I replace all < with < and all > with > and all that drollish crap that people use software to avoid. It’s especially fun when the blog helpfully assumes I am using some secret tag when I use generics.

Anyway, first problem: well, some of my swapping was wrong. Second, everything was double-spaced thanks to the magic of me making the original textfile on a windows machine (crlf versus just cr).

I had to actually get the original source from the project I based the post on, perform the replacement, paste it into the proper tag, and hope the gods of blog software were smiling upon me.

Long story short- Putting code in posts is more painful than it should be. I sort of expected the add-in I use for highlighting and code blocks to have been smart enough to properly mark-up the text itself without intervention, but no such luck.

Snippets.

BC_Programming — Thu, 03 May 2012 22:58:10 +0000

Naturally, as we write programs we create a small set of useful functions. BASeBlock has been no exception. I’ve created quite a few functions that offer generic functionality that could be used elsewhere. Here, I share some of them.

Value Clamping

Clamping values is a very common activity. It started to get on my nerves, repeating code to make sure a given value was within a range. As a result I conceived of a generic function that could be used for any IComparable.

public static T ClampValue (T Value, T min, T max) where T:IComparable
{
//cast to IComparable
IComparable cvalue = (IComparable)Value;
IComparable cmin = (IComparable)min;
IComparable cmax = (IComparable)max;
//return (T)(cvalue.CompareTo(cmin)< 0 ?cmin:cvalue.CompareTo(cmax)>0?max:Value);
if (cvalue.CompareTo(cmin) < 0)
{
return min;
}
else if (cvalue.CompareTo(cmax) > 0)
{
return max;
}
return Value;
}

The basic idea is fairly simple. First, in order to clamp the value, we will need to be able to compare them, so we constrain the function to accepting only type T’s that implement that interface. The first step is casting each value to an IComparable; then we use those variables to compare and return the appropriate value. if the value is larger than max, max is returned; if it is smaller than min, min is returned. otherwise, value is returned unchanged. This function is most useful for numbers, but it can also have interesting implications and usage cases for other classes that are comparable, even strings.

choosing N items from a Enumerable list of S

This also came up quite a lot- some parts of the game needed to randomly choose some set of values from a larger set of values. Naturally this gave birth to another generic routine for the purpose:

public static T [] Choose(IEnumerable ChooseArray, int numselect)
{
Random rgen = new Random();
T [] returnarray = new T [numselect] ;
SortedList sorttest = new SortedList();
foreach (T loopvalue in ChooseArray)
sorttest.Add(rgen.NextDouble(), loopvalue);
var usearray = sorttest.ToArray();
for (int i = 0; i < numselect; i++)
{
returnarray [i] = usearray [i] .Value;
}
return returnarray;
}

The idea is simple- make a SortedList that sorts the given listing using a random value as a key, then take the top numselect items off the top. This code will not work properly if numselect is larger than the size of the enumeration, but using count to clamp the size of the array would enumerate twice.

It’s probably possible to make this faster- possibly much faster- since we only need numselect elements. The core idea here is to shuffle the input array and choose two elements. One flawed approach for shuffling an array is to choose a random index and swap it with another random index, but this has myriad problems since it doesn’t really guarantee that everything is shuffled, and the result could very well have runs of the original card order.

Now, what if we had three objects we wanted to randomly choose from, and we wanted one of them to be chosen more frequently? One way of doing this is to use the above choose function and add duplicate entries. However, this could be tricky if you had odd requirements. This is where the Select function would come in. this function is designed to accept an array and a corresponding array of probability weightings; if all the weightings are equal, than the result should be similar to what we get from Choose. Select accomplishes this by keeping it simple. each array element is essentially assigned a given range within the total, and a random number is generated from the complete total of all weightings. For example, if we had the following elements:

#	Name	Weight
1	Billy	15
2	Thomas	35
3	Jack	70
4	Selmac	40
5	Patrick	80

We can see that if we generate a value between 0 and 240, than if it is between 0 and 15, we choose Billy, if it is between 15 and 50, we choose Thomas, etc.

Here is the code for the Select Function:

public static T Select(T [] items, float [] Probabilities)
{
return Select(items,Probabilities,new Random());
}
public static T Select(T [] items, float [] Probabilities,Random rgen)
{
//first, sum all the probabilities.
//we do this manually because we will also build a corresponding list of the sums up to that element.
float getsum = 0;
float [] sumulations = new float [Probabilities.Length + 1] ;
for (int i = 0; i < Probabilities.Length; i++)
{
sumulations [i] = getsum;
getsum += Probabilities [i] ;
}
sumulations [sumulations.Length-1] = getsum; //add this last value in…
//get a percentage using nextDouble. we use doubles, just in case the probabilities array uses rather large numbers to attempt to prevent
//abberations as a result of floating point errors.
double usepercentage = rgen.NextDouble();
//convert this percentage into a value we can use, that corresponds to the sum of float values:
float searchtotal = (float)(usepercentage * getsum);
//now find the corresponding index and return the corresponding value in the items array.
for (int i = 0; i < Probabilities.Length; i++)
{
if (searchtotal > sumulations [i] && searchtotal < sumulations [i + 1] )
return items [i] ;
}
return default(T);
}

A short test Main() routine that can be used to… test it:

static void Main(string [] args)
{
int totalcount = 50000;
String [] names = new string [] { "Bill", "Tom", "Dick" };
float [] probability = new float [] { 50, 20, 30 };
Dictionary countrunner = new Dictionary ();
Console.WriteLine("running simulations…");
for (int i = 0; i > totalcount; i++)
{
String Selected = Select(names, probability);
if (!countrunner.ContainsKey(Selected)) countrunner.Add(Selected, 0);
countrunner [Selected] ++;
}
Console.WriteLine("Completed. Results:");
foreach (var iterate in countrunner)
{
Console.WriteLine(iterate.Key + "\t\t\t" + iterate.Value.ToString() + " " + ((float)iterate.Value)/(float)totalcount);
}
Console.ReadKey();
}

The test is created in such a way that the values can be thought of directly as percentages. The resulting output shows that after a run the occurences of each lie around the percentages as given; Bill appears 50 percent of the time on average, Tom 20 percent, Dick 30 percent, etc. Obviously there is no requirement that the values add up to 100, but the values end up as percentages anyway. (choosing the values 100,40, and 60 for the probability array results in similar results).

This particular method has a bit of a “problem”; what if we run it repeatedly on the same array? Then we are constantly recreating the sumulations array and calculating the totals. How can we cache it? Easy- we use a Dictionary and keep weak references to the given array.

But all is not that simple! This is a generic method and the type T could easily change between calls- so what do we do? Well, it is possible to create a static object that contains a Dictionary indexed by a Type that has a value that is a KeyValuePair>, and then inspect the Dictionary for the appropriate values, make sure the cache doesn’t get to big, dispose ofthe WeakReferences that point to arrays that have since been destroyed, blah blah, tricky business. We don’t want that, because for one thing it will be a pain to write- and for another, it will probably be slower overall to begin with. Instead, how about absolving the method itself from the responsibility, and having a ref parameter that can accept a calculated sum array.

For me, the above testing Main() routine took 200ms to execute, on average (I placed calls to System.Diagnostics.Stopwatch members before and after the loop). There was no appreciable difference in speed. Thnakfully, however, the extra logic did not slow it down, either.

The speed improvement can be seen when we have a lot more members. With 5000 members in the probability and Values arrays, and executing a Select on them 50,000 times, the average time was around 5-6 seconds. When the Main function instead gave a float [] ref as the third parameter, the average time dropped to one second. The code for the revised version of the procedure. This also adds some overloads:

public static T Select(T [] items, float [] Probabilities)
{
return Select(items, Probabilities, new Random());
}
public static T Select(T [] items, float [] Probabilities, Random rgen)
{
float [] sumulator = null;
return Select(items, Probabilities, rgen, ref sumulator);
}
public static T Select(T [] items, float [] Probabilities, ref float [] sumulations)
{
return Select(items, Probabilities, new Random(), ref sumulations);
}
public static T Select(T [] items, float [] Probabilities,Random rgen, ref float [] sumulations)
{
//first, sum all the probabilities; unless a cached value is being given to us.
//we do this manually because we will also build a corresponding list of the sums up to that element.
float getsum = 0;
if(sumulations ==null)
{
sumulations = new float [Probabilities.Length + 1] ;
for (int i = 0; i < Probabilities.Length; i++)
{
sumulations [i] = getsum;
getsum += Probabilities [i] ;
}
sumulations [sumulations.Length-1] = getsum; //add this last value in…
}
else
{
getsum = sumulations [sumulations.Length-1] ;
}
//get a percentage using nextDouble. we use doubles, just in case the probabilities array uses rather large numbers to attempt to prevent
//abberations as a result of floating point errors.
double usepercentage = rgen.NextDouble();
//convert this percentage into a value we can use, that corresponds to the sum of float values:
float searchtotal = (float)(usepercentage * getsum);
//now find the corresponding index and return the corresponding value in the items array.
for (int i = 0; i < Probabilities.Length; i++)
{
if (searchtotal > sumulations [i] && searchtotal < sumulations [i + 1] )
return items [i] ;
}
return default(T);
}

A lot of the above could even be implemented as Extension methods to the appropriate classes, making it seamless.

Since I am working on a game, dealing with vectors and speeds and whatnot is common. One frequent requirement is for items to move at a random angle at a random speed within a given range. The obvious base case here is creating a Vector given a angle and a magnitude:

public static PointF GetVelocity(double speed, double angle)
{
return new PointF((float)(Math.Cos(angle) * speed), (float)(Math.Sin(angle) * speed));
}

This uses standard trigonometry to calculate what would be the X and Y axes of a fictitious triangle with the given direction as it’s hypoteneuse. Extending from this, we simply create a few extra routines that perform the randomizations:

public static PointF GetRandomVelocity(double minspeed, double maxspeed, double angle)
{
return GetRandomVelocity(minspeed,maxspeed,angle,new Random());
}
public static PointF GetRandomVelocity(double minspeed, double maxspeed, double angle, Random rgen)
{
return GetVelocity(minspeed + (rgen.NextDouble() * (maxspeed-minspeed)),angle);
}
public static PointF GetRandomVelocity(double minspeed, double maxspeed, Random rgen)
{
return GetRandomVelocity(minspeed,maxspeed, Math.PI*2*rgen.NextDouble(),rgen);
}

easy as 3.1415926!

Another interesting endeavour is simplifying the otherwise messy world of Object serialization, such as easily converting a Serializable Object to and from a Stream:

[code]

public static void ObjectToStream(T saveme, Stream outstream) where T : ISerializable

{

BinaryFormatter bf = getFormatter();

using(GZipStream gz = new GZipStream(outstream,CompressionMode.Compress))

{

bf.Serialize(gz, saveme);

}

public static T StreamToObject(Stream instream) where T : ISerializable

{

BinaryFormatter bf = getFormatter();

using(GZipStream gz = new GZipStream(instream,CompressionMode.Decompress))

{

return (T)bf.Deserialize(gz);

}

[/code]

This also plonks in a bit of compression through the use of a GZipStream.

Anyway, that’s a quick sampling of a few snippets of possible usefulness

AMD & Intel, Past, Present & Future

BC_Programming — Sun, 25 Mar 2012 20:34:53 +0000

AMD, like Cyrix VIA, and Nextech (I believe was the name) were all clone makers, they made pin compatible processors for PCs. Their primary advantage was their lower cost. the AMD k5, designed to compete with the Pentium, as a Socket 5 processor just like the Pentium. The idea was that as a lower cost alternative their processors could be used in machines instead of Intel's. AMD, specifically, excelled in integer operations, doing them a lot faster than the equivalent Intel Processor. So in some cases the AMD processor was not only cheaper but also a better choice, if it was for use in applications that did a lot of integer arithmetic. Nextech was working on a new processor to compete with the Pentium and the K6; AMD bought the company and relabelled the in-development Nextech chip the K6-2; the K6 and K6-2 are completely different processors, and not in any way the same (they were basically designed by two different companies). The K6-2 supported a set of 3-D extensions (much like MMX)- whether this was Nextech or AMD that implemented it, I don't remember- at the same time it supported MMX, and it's floating point performance no longer sucked ass, and was very nearly comparable to Intel's offering.

Over time, all the other clone vendors died, or were purchases; VIA, to my recollection, bought Cyrix, made a few processors (the VIA Samuel C3 being the only one I distinctly recall) and then killed their processor division entirely, focusing on their motherboards and embedded solutions. AMD became the only competitor to intel that had any “weight”. Also, as their processors became equal to Intels both in performance and price, they started being made using different Pin designs. I believe this was originally because the socket or slot for some Pentium processor was patented so AMD couldn't make a compatible equivalent; at the very least, the Pentium itself was named the Pentium- rather than the 586- in order to prevent other vendors from using the same name.

One interesting thing about the Pentium Processor is that it is the first CISC instruction set processor to be considered SuperScalar. This is because of it's pipeline architecture which allows it to, in many cases, execute two instructions per clock cycle. The Pentium came in two revisions; the earlier versions didn't have things like MMX, and in many cases had the infamous FPU issue (Intel Errata #23). The second generation came in higher clock speeds (90Mhz, 100Mhz,and 133Mhz, as opposed to the 50 and 75Mhz of their original incarnations), as well as any number of improvements, such as a smaller die size and an on-chip APIC. It didn't have MMX, that was the third revision, which came in even higher clock speeds, FSB/Clock:66/166,66/200,66/233,66/266 (mobile only for the last one). the third revision had MMX, a smaller still die size, lower voltage requirements, a 16KB write-back cache (compared to the earlier versions 8KB). The interesting thing about some pentium boards, including those designed for slot CPUs, is that a lot of them actually had two processor slots. Usually the second one was labelled “for testing only” but you could literally plug in another processor and have dual processors. The only downside is that you pretty much required Windows NT to use them (9x doesn't support multiple cores or processors). Heck that wouldn't even work with XP Home, which only supports a single physical processor.

AMD's lower cost offerings impacted Intel's market, so they came up with their own low-cost alternatives. Which isn't too surprising given they'd been doing that for years, with the 386SX and 486SX, The 386SX being a slower variant of the 386DX, whereas the 486SX was a 486DX with it's FPU disabled. Installing the companion “co-processor”, the 487SX was actually installing a 486DX, which then took over all system operations from the SX. In addition, they created lower-cost upgrade capabilities for the 486, since the k5 was almost feature par with the pentium (and better in some ways, with 6 5-stage instruction pipelines rather than 2). To compete with this they created the Pentium “Overdrive” chip, which would be installed in a 486DX board, and take over all operations from the installed 486DX. Naturally, it was on a 486 board so some operations would still be slow, particularly bus transfers and DMA, but it sped up processor intensive tasks, and sped up a lot of tasks because of that. Later, with the K6 and K6-2 eating into their Pentium II Market share, they came up with another lower cost segment, the Pentium Celeron.

sidebar:*technically, the first Intel 6th generation processor was not the Pentium II, but rather the Pentium Pro*

Of important note is that the first Celerons were not Pentium processors, but rather Pentium II processors; it took a generation for Intel to catch on to AMD's low-cost niche tactic and come up with a response in the celeron. The Celeron was typically a slotted processor, at least all that I've seen are. The basic difference is that it has less on-die cache, and no L2 cache (some revisions had 128KB, compare to the Pentium II's standard 512KB). Ironically, the Celeron usually performed much worse than the K6 and K6-2 it was designed to compete with; Not to mention the awkwardness of the slotted processor design. Even so, and particularly through partnerships with retail computer manufacturers, Intel was able to squeeze the Celeron boards into the market. (the “Barbie” and “Hot wheels” machines from mid to late 1998 are a good example of this, since they sported celeron processors). The Celeron Brand lives on, but it is still a lower cost alternative to their other offerings, and is almost never a wise choice for a desktop machine. Many users are woo'd by the higher clock speed, but with so little cache, the clock speed barely compensates.

The 6th generation gave us the above Pentium II's, Celerons and K6-2s; the seventh gave us Pentium 2s…. Wait? P2s? What about Pentium III's and K6-2s? Well, they aren't 7th gen processors, since they are based on the same die as the sixth gen chips (for Intel, this was the Pentium Pro, for AMD, the K6-2).

The Original Pentium III was practically a Pentium 2 with SSE (MMX2) and a higher clock speed. An interesting sidebar is that the P6 chips from intel (pentium Pro, Pentium II, and Pentium III) are only fully utilized by NT versions of windows; since the Microops that the CISC instructions are reduced to are optimized for use with 32-bit code. windows 9x executes a good half of the time in 16-bit mode (for compatibility with older software, mostly) so you don't get the biggest improvement with it.

Intel failed miserably on their first attempts at a consumer-appealing x64 architecture. The Itanium was 64-bit, but it's execution of 32-bit code had to be fully emulated. It found some uses in business and servers, but it's limited ability with 32-bit code abhorred it's adoption in the consumer sector.

AMD created it's own 64-bit processors, but made it so that 64-bit was just another “mode” of the processor. In this way, 32-bit code could be run quite easy with minimal virtualization. Intel followed suite with their own extensions that implemented the same instruction set as AMD, making it compatible.

I'm not nearly as familiar with their history after around the Pentium III/Athlon XP area.

The two are practically the same now. They offer consumers a choice, but at the same time that choice is practically useless. The fact is that we've pretty much hit the architectural limit that different die configurations can give us, and we are not easily able to reduce the process further without invoking the dangers of quantum tunnelling. The best considerations for the future is to add more processor cores, and, even more important, have software that is better able to extort the best power from those cores. My opinion is that the big problem right now is not the hardware, or the software, but rather the programming languages that are dominant in the industry today, largely C/C++. What is needed is the adoption of one of the myriad languages that have built in support for concurrent execution of constructs; for example, some languages are able to compile a simple for iterative construct in a way that it can execute on separate cores. This approach is particularly powerful in a stateless environment, such as a functional language. to that end many functional languages include built-in concurrency support. What makes this particularly interesting is that most programmers think of “concurrency” and immediately think of threads; but threading is only one of the ways that concurrency can be achieved, and it is one of the least powerful, as well. Erlang, for example, takes the approach of sending messages between processes, instead of having different threads. Since Erlang is a functional' language, most of it's constructs are largely stateless; this is as opposed to most imperative languages which are typically state-heavy. It is the abundance of state in our standardized' programming languages that is causing the difficulties we are seeing with concurrency, not the cores or the implementations thereof. Consider for a moment that most of the benchmarking tools being used to compare processors are he written in C/C++. In order to trust the performance results, you have to trust that the code is making the best use of the available hardware. But the fact is that imperative stateful programming abhors concurrency; threads deadlock, and you have data synchronization issues and race conditions to deal with. So, while processor performance benchmarks might state that a Bulldozer is “worse” than another CPU, I move that that result is as much a testament to weaknesses in the program and the stateful imperative programming paradigm at least with regards to it's use with concurrent solutions. This is why I have never put faith in benchmarks; the fact is that any weakness being shown could easily be an oversight or problem with the software being used to test. If a benchmark tool only uses two threads, how can you trust it's result when it runs on 6 cores? And even if it was to use more, you're still placing your trust in how the program was written. And while one could argue that the test will show how a lot of current software and games run on a given system, it doesn't test the actual potential of that system; a properly written game could be written to take advantage of 6 cores and it would scream compared to running that program with fewer cores. At this point, concurrency is the answer to improving system speed, and in order to properly leverage concurrency, we don't just need more cores, but we need software and programming languages that provide built-in support for concurrency constructs. C/C++ simply does not offer this, and while I'm sure a library could be written that does, there are already loads of languages that provide built-in support for concurrency in any number of different ways; either through C# and .NET's addition of parallel constructs in C# 5.0, or the ability of functional languages to make assumptions because the code is primarily stateless and thus easier to make parallelize.

Personally I don't have a preference for either. I used a K6-2 for nearly 5 years, a Pentium 4 for about a year, and am now using Intel Q8200 and a laptop with a Intel T3200 (I think). Maybe my next build wilent l be AMD, I don't know. Either way, I'm not going to base any of my choices on how a given system performed with a piece of software. The heart of the matter is that I never trust software. I don't even trust software I wrote half the time. Software is a loose thread on a sock. If you pull out the thread, the sock is going to fall down regardless of how well formed the ankle is, and you cannot declare “this ankle sucks, because my sock keeps falling down” just as you cannot say “This hardware sucks, because this piece of software says so”.

Why I use INI Files, and a FormPositionSaver class

BC_Programming — Thu, 12 Jan 2012 23:11:01 +0000

In some of my recent posts, I’ve covered the topic of accessing and parsing an INI file for configuration data in a C# Application.

Some may wonder why. After all; the “norm” for C# and .NET applications is to use XML files for configuration information, isn’t it? Well, yes. But to be honest, XML files are a fucking pain in the ass. They aren’t human readable to your average person the same way an INI file is, and getting/setting values is tedious. Primarily, the reason I use INI files is that they are:

Human Readable: Anybody can understand the basic structure of the sections and Name=Value syntax.
Accessible: You don’t need a special editor
Portable: since the entire thing is interpreted using Managed code, it will act the same on any platform (Mono or the MS CLR).

Mostly, I feel that XML, and in many ways other configuration options, are more or less driven by fad. Another option for configuration settings on Windows is the Registry, which is in fact often the recommended method; but this is anything but accessible to the user. Would you rather guide a user to edit a INI file or to fiddle with registry settings?

With that said, INI Files do have their own issues. For example, their data is typically typeless; or, more precisely, the Values are all strings. Whereas using a .NET XML Serializer, for example, you could easily(relatively speaking) serialize and deserialize a special configuration class to and from an XML file and preserve it’s format, with my INI file class there will typically be some work to parse the values.

It was with the idea of turning my string-only INIFile configuration settings into something that can be used for nearly any type that I created the INItemValueExtensions class, which is nothing more than a static class that provides some extension methods for the INIDataItem class. I covered this in my previous post.

The prototypes for the two static functions are:

public static T GetValue(this INIDataItem dataitem, T DefaultValue);
//and
public static void SetValue(this INIDataItem dataitem, T newvalue);

How would one use these extension methods? Well, here’s an Example:

public static void main(String [] args)
{
INIFile loadini = new INIFile("D:\\testini.ini");
loadini ["Dates"] ["TestDate"] .SetValue(DateTime.Now);
DateTime readvalue = loadini ["Dates"] ["TestDate"] .GetValue ();
}

Woah, hold the phone! What’s going on here? We’re loading DateTime values directly from the INI File? How does that work?

All the “magic” happens in the getValue generic extension method. The first thing the routine does is check to see if the Type Parameter has a static TryParse() method; if it implements ISerializable and have a TryParse method, than the routine will read the string from the INI file, decode it via Base64, and throw it in a MemoryStream, and then try to deserialize the Object Graph for a Type T using that stream.

If it does implement a TryParse() routine, (like, for example, DateTime) it doesn’t try quite as hard. It takes the string from the INI file and hands it to the Type’s TryParse() routine, and then returns what that gives back. Naturally, the inverse function (setValue) does something somewhat opposite; it checks the Base64 logic, and if so it sets the value of the item to the Base64 encoded value of the serialized object. Otherwise, it just uses toString().

This typically works, particularly with DateTime, because usually ToString() is the inverse of TryParse(). In the case of DateTime, this has a few edge cases with regards to locale, but usually it works quite well. And more importantly, the introduction of allowing any object that implements ISerializable to simply be thrown as an INI value via a Base64 encoded string is useful too, although with large objects it’s probably not a good idea for obvious reasons.

But… I still want to access other settings!

Of Course, an INIFile is only one of any number of ways to store/retrieve configuration settings. And while they don’t typically lend themselves to the same syntax provided by the INIFile class, it would be useful to have some sort of common denominator that can handle it all. That was the original intent of the relatively unassuming ISettingsStorage interface:

public interface ISettingsStorage
{
void Save();
void Load();
void AddValue(String Category, String ValueName, String Value);
String GetValue(String Category, String ValueName);
}

This uses a concept known as a “category” which is pretty much the same idea as an INI File section. What makes it different is that, for implementors that use other storage mechanisms, it could have additional meaning; for example, a fictitious XML implementation of ISettingsStorage could use the “Category” string as an XPath to an element; and the Value could be stored/retrieved as a Attribute. a Registry implementation might use it as a Registry path, and so on.

The problem is, even though the INIFile class implements this interface, it’s too basic, and doesn’t provide nearly the syntactic cleanliness that just using the INIFile does. Stemming from that, and because I wanted to try to get a way to store settings directly in a DB, I introduced two events to the INIFile class; one that fires when a Value is retrieved, and one when a value is saved. This way, the event could be hooked and the value saved elsewhere, If desired. Now, to be fair, this is mostly a shortcoming of my interface definition; as you can see above, there is no way to, for example, inspect category or Value names. I toyed with the idea of adding a “psuedo” category/value combination that would return a delimited string of category names, but that felt extremely silly. The creation of a generic interface- or abstract class- that provides all the conveniences I currently enjoy using my INIFile class but allowing me to also use XML, Registry, or nearly any other persistent storage for settings will be a long term goal. For now, I’m content with accessing INI files and having a unclean event to hack in my own behaviour.

My first test of the above feature- whereby it allows values to be TryParse’d and ToString’d back and forth from a given type on the fly- was the creation of a FormPositionSaver class.

The proper way to save and restore a window’s position on Windows is using the GetWindowPlacement() and SetWindowPlacement() API Functions. These use a structure, named, quite aptly, “WINDOWPLACEMENT” to retrieve and set the window position and various attributes. Therefore, our first task is to create the proper P/Invoke’s for these functions:

[DllImport("user32.dll")]
private static extern int OffsetRect(ref RECT lpRect, int x, int y);
[DllImport("user32.dll")]
private static extern int GetWindowPlacement(IntPtr hwnd, ref WINDOWPLACEMENT lpwndpl);
[DllImport("user32.dll")]
private static extern int SetWindowPlacement(IntPtr hwnd, ref WINDOWPLACEMENT lpwndpl);

I also include OffsetRect(), but I’ll get to that in a bit. Now the “big one” is the definition of the WINDOWPLACEMENT structure and it’s various aggregate structures. Why? well, in the interest of leveraging the INIFile’s static extensions, Why not define a static TryParse() and a toString() method on the structure that can set and retrieve the member values:

[StructLayout(LayoutKind.Sequential)]
private struct POINTAPI
{
internal int x;
internal int y;
public POINTAPI(int px, int py)
{
x = px;
y = py;
}
public static void TryParse(String parseit, out POINTAPI result)
{
//format: (X,Y)
//strip out parens.
String [] parsed = parseit.Replace("(", "").Replace(")", "").Split(new char [] {‘,’});
int kx = int.Parse(parsed [0] );
int ky = int.Parse(parsed [1] );
result = new POINTAPI(kx, ky);
}
public override string ToString()
{
return "(" + x + "," + y + ")";
}
}
[StructLayout(LayoutKind.Sequential)]
private struct RECT
{
internal int Left;
internal int Top;
internal int Right;
internal int Bottom;
public override string ToString()
{
return "{" + new POINTAPI(Left, Top).ToString() + "-" + new POINTAPI(Right, Bottom).ToString() + "}";
}
public RECT(int pLeft, int pTop, int pRight, int pBottom)
{
Left = pLeft;
Top = pTop;
Right = pRight;
Bottom = pBottom;
}
public static void TryParse(String parsestr, out RECT result)
{
//strip out braces…
parsestr = parsestr.Replace("{", "").Replace("}", "");
//split at ")-("…
String [] Pointstrings = parsestr.Split(new string [] {")-("}, StringSplitOptions.RemoveEmptyEntries);
POINTAPI firstpoint, secondpoint;
//parse the resulting values. re-add the parens that were removed by the split.
POINTAPI.TryParse(Pointstrings [0] + ")", out firstpoint);
POINTAPI.TryParse("(" + Pointstrings [1] , out secondpoint);
result = new RECT(firstpoint.y, firstpoint.y, secondpoint.x, secondpoint.y);
}
}
[StructLayout(LayoutKind.Sequential)]
private struct WINDOWPLACEMENT
{
internal int Length;
internal int flags;
internal int showCmd;
internal POINTAPI ptMinPosition;
internal POINTAPI ptMaxPosition;
internal RECT rcNormalPosition;
public override string ToString()
{
return String.Join(",", new string []
{
flags.ToString(), showCmd.ToString(),
ptMinPosition.x.ToString(), ptMinPosition.y.ToString(),
ptMaxPosition.x.ToString(), ptMaxPosition.y.ToString(),
rcNormalPosition.Left.ToString(), rcNormalPosition.Top.ToString(),
rcNormalPosition.Right.ToString(), rcNormalPosition.Bottom.ToString()
});
}
//parsed a string into a WINDOWPLACEMENT structure.
public static bool TryParse(String parseme, out WINDOWPLACEMENT result)
{
try
{
String [] splitvalues = parseme.Split(‘,’);
int [] parsedvalues = new int [splitvalues.Length] ;
for (int i = 0; i < parsedvalues.Length; i++)
{
int.TryParse(splitvalues [i] , out parsedvalues [i] );
}
result = new WINDOWPLACEMENT
{
flags = parsedvalues [0] ,
showCmd = parsedvalues [1] ,
ptMinPosition = new POINTAPI(parsedvalues [2] , parsedvalues [3] ),
ptMaxPosition = new POINTAPI(parsedvalues [4] , parsedvalues [5] ),
rcNormalPosition =
new RECT(parsedvalues [6] , parsedvalues [7] , parsedvalues [8] , parsedvalues [9] )
};
return true;
}
catch
{
result = new WINDOWPLACEMENT();
return false;
}
}
}

WHEW! that’s quite a bit of code for a structure definition, but we’ll make up for it with the brevity of the actual FormPositionSaver class itself. First, my design goal with this class was to make it basically do all the heavy lifting; it hooks both the Load and Unload event, and saves to and from a given INIFile Object in those events. Since the application I was working on at the time didn’t actually get a Valid INI object until during it’s main form’s Load event, and since there is no way to say “Invoke this event first no matter what” I also added a way for it to be told that hooking the load event would be pointless since it already occured, at which point it will not hook the event and instead set the form position immediately. Values are stored

public class FormPositionSaver
{
private Form FormObject = null;
private INIFile Configuration = null;
private static readonly String usesectionName = "WindowPositions";
///
/// Create the FormPositionSaver
///
/// Form to deal with
/// INIFile to load and save
/// whether the Load event has fired. If true, will try to set the form position immediately. otherwise, it hooks the Load event and waits.
public FormPositionSaver(Form FormObj, INIFile configfile, bool alreadyloaded)
{
Configuration = configfile;
FormObject = FormObj;
FormObject.FormClosed += new FormClosedEventHandler(FormObject_FormClosed);
if (!alreadyloaded)
FormObject.Load += new EventHandler(FormObject_Load);
else
{
FormObject_Load(FormObject, new EventArgs());
}
}
//save the placement...
private void FormObject_FormClosed(object sender, FormClosedEventArgs e)
{
//save placement.
//all the "tough work" is handled above, and by the INIDataItem Extension methods. Here we
//can simply use SetValue <> and set the value. Nice and clean.
WINDOWPLACEMENT grabplacement = new WINDOWPLACEMENT();
GetWindowPlacement(FormObject.Handle, ref grabplacement);
Configuration [usesectionName] [FormObject.Name] .SetValue(grabplacement);
}
//Load event: load the form placement, if present, from the INI file we were given in our constructor.
private void FormObject_Load(object sender, EventArgs e)
{
WINDOWPLACEMENT currplacement = new WINDOWPLACEMENT();
GetWindowPlacement(FormObject.Handle, ref currplacement);
//default is wherever it is now if there is a parse problem.
WINDOWPLACEMENT getplacement =
Configuration [usesectionName] [FormObject.Name] .GetValue(currplacement);
//check for previous instances, and offset if there are.
String thisproc = Process.GetCurrentProcess().ProcessName;
Process [] existing = Process.GetProcessesByName(thisproc);
if (existing.Length > 1)
{
//more than one, so offset...
OffsetRect(ref getplacement.rcNormalPosition, 16*existing.Length, 16*existing.Length);
}
SetWindowPlacement(FormObject.Handle, ref getplacement);
//load placement...
}
}

Alright, so maybe I lied a bit. It's not super short. Although a lot of it is comments. Some might note that I only sporadically add doc comments, even though I ought to be adding them everywhere. Well, sue me. I just add them when I feel like it. When I'm concentrating on function, I'm not one to give creedence to form.

This is where I explain OffsetRect(). Basically, if your application is run twice, and you load the form position twice, the second form will open over the first one, and the screen will look pretty much the same. So we detect previous instances and offset by an amount to make it's position different from any previous instances as necessary. That's pretty much the only purpose of OffsetRect.

I have packaged the current versions of cINIFile.cs and the new FormPositionSaver.cs in a zip file, it can be downloaded from here .

the illusion of Market Share and software

BC_Programming — Sun, 08 Jan 2012 06:13:50 +0000

When speaking of browsers, Operating Systems, or various other pieces of technology, people will often speak of “market share”. I’ve always found it somewhat puzzling; the term Market share implies that the various selections are mutually exclusive. The thing is though, that simply isn’t the case

Take Linux “market share” for example. I use windows, as my primary OS, but I also use Linux on my laptop. Where do I fall? Who’s Market share do I increment? I use firefox usually as my browser, but I have Chrome, Opera, and IE installed. Does having them installed count towards market share? And if not, how often do I have to use them before they “count”, and who decides that?
Basically, once people start bleating about market share, they’d lost grip with the facts. There is no “market share” anymore; it’s all about Mind Share.

Anyway that’s a quick post from me. In other news I’ve got some additions to my INIFile.cs class (including a fix) that should make a juicy entry,too.

A dynamic New Year’s Post

BC_Programming — Mon, 02 Jan 2012 01:20:45 +0000

HAHA! How’s that for a clever title?

Oh… well… ahem… nevermind.

As a avid user of my own INIFile class, which I first write about- at least it’s C# implementation- in my parsing INI files posting , I am always looking for ways to improve it’s usage make it more “accessible”.

Recently, I have been tasked (by way of my new title of “freelance consultant”) with creating several LOB (Line of Business) Type applications. Applications, naturally, have a tendency to lend their implementations to the creation and reading of settings. Being something of a fan of the simplicity of INI Files, I chose to use my INIFile class in the application. It works well, however, I have noticed that I have a lot of duplicate code. More specifically, I typically have to implement a “wrapper” class, which manages configuration information and reads/writes values to and from the INIFile as its own properties are accessed. For example:

public bool PopulateUserOrderDropdown
{
get {
bool tparse;
if(bool.TryParse(OurINI ["Admin.Settings"] ["PopulateUserOrderDropDown","false"] .Value,out tparse)
return tparse;
return false;
}
set { OurINI ["Admin.Settings"] ["PopulateUserOrderDropDown"] .Value;}
}

Nothing too dreadful, but imagine having nearly the exact same thing repeated a number of times! The code is repeated and as Larry Wall says, one of the traits of a good programmer is sloth. I don’t like having to write this same code over and over again! The INIFile is supposed to make it easy!

The trouble here stems from the fact that the INIFile values are only strings; and typically, many settings are represented in the application itself as integers and booleans, dates, and so forth. My first attempt to mitigate the clutter was a static method, which I called xParse:

public static class boolEx
{
public static bool xParse(String Value, bool Default)
{
bool parseresult;
if(bool.TryParse(Value,out parseresult))
return parseresult;
else
return Default;
}
}

relatively straightforward- basically it’s a shell of what I had repeated over and over again. This mitigated the issue somewhat, so my properties in the wrapper looked like this:

public bool PopulateUserOrderDropdown
{
get { return boolEx.xParse(OurINI ["Admin.Settings"] ["PopulateUserOrderDropDown", "false"] .Value); }
set { OurINI ["Admin.Settings"] ["PopulateUserOrderDropDown"] .Value;}
}

much more managable, but still, could we not make this more concise? My first thought, was that perhaps I could eliminate the necessity of having the wrapper at all; I recalled two interfaces from my old COM programming days, specifically, IDispatch and IDispatchEx. Surely, I could do something similar?

Unfortunately, the interfaces are for COM, and C# doesn’t have dynamics until Version 4.

So, I fired up Visual Studio 2010 express to see if I couldn’t add the dynamic language constructs to the INIFile class; additionally, since I still need to work with .NET 3.5, I’ll add the new code as a conditional compilation.

The first step was deciding exactly what I wanted to happen. Imagine code like this:

INIFile useINI = new INIFile("settings.ini");
String ConnectionString = (String)useINI.General.ConnectionString;

The holy grail of the INIFile simplicity! Naturally, the .NET framework does provide the facility with which to add this functionality, as part of the System.Dynamic namespace.

The first step was deciding on the method by which to conditional compile. Since projects copy the source of a file to your project folder when you add them, it seemed reasonable to simply add it as a #define right inside the INIFile class itself.

 #define CS4

And now, I just need to enclose all my new happy stuff in a conditional directive, and I’ll get the best of both worlds- C# 4.0 consumers who keep the #define will be able to use the suave new feature, and older consumers will still be able to work without ripping apart the classes. The code to add this was surprisingly simple; as it stands now the longest method (An implementation of TryDeleteMember, which is never called from C#/VB.NET consumers, so is excessive for my usage). First, obviously we enclose the import statement in the conditional compile; the class headers are conditionally compiled as well, only deriving from DynamicObject with CS4 set.

The core of the new functionality is in the overrides to the Dynamic Object’s TryGetMember.

For the INISection:

public override bool TryGetMember(GetMemberBinder binder,out object result)
{
result = this [binder.Name] ;
return true;
}

And for the INIFile…

public override bool TryGetMember(GetMemberBinder binder,out object result)
{
result = this [binder.Name] ;
return true;
}

Exactly the same, in fact. This works because of the indexer I added; the indexer will add the item if it doesn’t exist and return the new value, so even if the member name doesn’t exist, the INIFile will simply have that section added.

That’s for the retrieval of erements; to allow the assignment to them in the same fashion, we need to override TrySetMember(). In my case, this was a bit more involved, for flexibility purposes.

For example, code like INIFile.MainSection=”hello” should work, and change the name of the section. And why allow things like assignments from a Dictionary, or maybe even a list (assigning a numbered id to set values)? And of course allow setting the Value directly, which will likely use the indexer much as I did for the TryGet… Implementations.

public override bool TrySetMember(SetMemberBinder binder, object value)
{
//if it is a dataitem, set it directly.
if (value is INIDataItem)
{
this [binder.Name] = (INIDataItem)value;
return true;
}
else if (value is Tuple<, Object>)
{
Tuple<, Object> theTuple = (Tuple<, Object>)value;
INIDataItem getitem = this [binder.Name] ;
getitem.Name = theTuple.Item1;
getitem.Value = theTuple.Item2.ToString();
return true;
}
else if (value is Tuple<, String>)
{
Tuple<, Object> theTuple = (Tuple<, Object>)value;
INIDataItem getitem = this [binder.Name] ;
getitem.Name = theTuple.Item1;
getitem.Value = theTuple.Item2.ToString();
return true;
}
else if (value is KeyValuePair<, Object>)
{
//Allow a KeyValuePair<,Object> to be passed to set Name and Value.
KeyValuePair<, Object> castedval = (KeyValuePair<, Object>)value;
INIDataItem getitem = this [binder.Name] ;
getitem.Name = castedval.Key;
getitem.Value = castedval.Value.ToString();
return true;
}
else if (value is KeyValuePair<, String>)
{
//Allow a KeyValuePair<,String> to be passed to set Name and Value.
KeyValuePair<, String> castedval = (KeyValuePair<, String>)value;
INIDataItem getitem = this [binder.Name] ;
getitem.Name = castedval.Key;
getitem.Value = castedval.Value;
return true;
}
else
{
this [binder.Name] .Value = value.ToString();
return true;
}
}

setting the Value should be equally flexible; since we can, why not?
for example, why not make the following “legal”?

INIFile.Section.Value="newvalue";
INIFile.Section.Value=DateTime.Now;
INIFile.Section.Value=Tuple.Create("NewName","Chicken");
INIFile.Section.Value=Tuple.Create("NewName",DateTime.Now);

The first example sets the Value to a string, the second sets it to a DateTime that is silently casted to a String (using toString(), and the last two use the new C# 4.0 tuples, to set both the name of the value and the value simultaneously.

A more elegant solution would be to add this code to the Indexer, and merely call the indexer with the name and the value and return true if no exception occurs and false otherwise. However, I’m reluctant to go that route since some of the types are C# 4 types (Tuples).

public override bool TrySetMember(SetMemberBinder binder, object value)
{
if (value is String)
{
this [binder.Name] .Name = (String)value;
return true;
}
else if (value is List)
{
INISection getsection = this [binder.Name] ;
getsection.INIItems = (List)value;
return true;
}
else
{
return false;
}
}

So Now, I’ve got an INI File implementation that supports Dynamic invocation. Well, that’s great… except that the application I first found it clumsy in is using .NET 3.5, so I can’t use the dynamic features. Back at square one.

In C# 2008/3, we might not be able to leverage the power of dynamics, but we do have generics and Extension methods at our disposal. a feasible alternative could be to add a extension method to the INIDataItem class that has a generic type parameter that it will attempt to convert it’s string Value into. First, using ChangeType, second, it can try to invoke a static TryParse on the given Type to parse the “value” string. And if none of that works, it can return a passed in default. This is still more verbose than the dynamic solution, but it has two distinct advantages- first, it’s type-safe, so you get all the intellisense goodness, and second, it’s still shorter than the alternative.

Here is the code, which can be found in the cINIFile.cs file attached to this posting as well.

public static class INItemValueExtensions
{
//extensions for INIDataItem
//normally, INIDataItem is a Name/Value Pair; More Specifically, because of the way INI files are, they are
//naturally typeless. However, most configuration options are mapped to a different type by the application.
//and I’ve found it to be a gigantic pain to have to write the same TryParse() handling code over and over.
//so I added these handy extensions to the INIDataItem class, which provide some functions for setting.
//I keep them out of the main code simply because that way it doesn’t clutter it up. It’s already cluttered enough as-is.
///
/// Attempts to use Convert.ChangeType() to change the Value of this INIDataItem to the specified type parameter.
/// If this fails, it will attempt to call a static "TryParse(String, out T)" method on the generic type parameter.
/// If THAT fails, it will return the passed in DefaultValue parameter.
///
/// Parameter Type to retrieve and act on in Static context.
/// INIDataItem instance whose value is to be parsed to the given type.
/// Default value to return
/// Result of the parse/Conversion, or the passed in DefaultValue
public static T GetValue(this INIDataItem dataitem, T DefaultValue)
{
//Generic method, attempts to call a static "TryParse" argument on the given class type, passing in the dataitem’s value.
try
{
return (T)Convert.ChangeType(dataitem.Value, typeof(T));
}
catch (InvalidCastException ece)
{
//attempt to call TryParse. on the static class type.
//TryParse(String, out T)
Type usetype = typeof(T);
T result = default(T);
Object [] passparams = new object [] { dataitem.Value, result };
try
{
bool tpresult = (bool)usetype.InvokeMember("TryParse", BindingFlags.Static, null, null, passparams);
if (tpresult)
{
//tryparse succeeded!
return (T)passparams [1] ; //second index was out parameter…
}
}
catch (Exception xx)
{
//curses…
return DefaultValue;
}
}
return DefaultValue;
}
///
/// Logical inverse of the getValue routine… a bit faster to implement…
///
///
///
///
public static void setValue(this INIDataItem dataitem, T newvalue)
{
dataitem.Value = newvalue.ToString();
}
private static void GetTypeDefault(out T result)
{
Type tt = typeof(T);
//basic idea: call default, empty constructor using reflection.
ConstructorInfo defaultconstructor = tt.GetConstructor(new Type [] { });
result = (T)defaultconstructor.Invoke(null);
}
}

And there you have it, a bunch of awesome additions. INI files are often thought of as deprecated, but that’s only the INIFile functions. This class was designed because working with the registry makes it difficult to test properly, and because JSON,YAML, and many other formats are excessively complicated. when you just need a few basic settings, all you need is the clean, simple format of a INI file. And now, with these additions, code for reading from those INI files is clean and simple as well!

The Source- cINIFile.cs

An Extension to the GenericListViewSorter class

BC_Programming — Sun, 25 Dec 2011 22:05:28 +0000

As I posted previously here , Sorting a Listview can be something of a pain in the butt.

In that article, I covered some basics on providing a class that would essentially give you sorting capabilities for free, without all the messy code that would normally be required. A lot of the code required for sorting is mostly boilerplate with a few modifications for sorting various types. As a result, the generic implementation works rather well.

However, as with any class, adding features never hurts. In this case, I got to thinking- why not have right-clicking the ColumnHeaders show a menu for sorting against that Column? Seems simple enough. I quickly learned that apparent simplicity often is misattributed.

I faced several issues. The first thought was that I could hook a Mouse event for Right-Clicking a column header. Unfortunately, I soon discovered two facts about the .NET ListView control. First, was that there was no event for right-clicking a header control. Second, no even was fired at all by the ListView control when you right-clicked a header.

This left me stymied. How the heck do I implement this feature? I discovered something of a “hack” however, in that when the ListView’s ContextMenuStrip property is set, that ContextMenu Strip will be shown regardless of the location the ListView is clicked. This at least gave me something to work with. Since a ContextMenuStrip’s “Opening” event can be easily hooked, we can use that as an entry point and perform needed calculations to determine if we are indeed on a columnheader.

Which brings me to the next problem, which is determining when a columnheader was in fact the item that was clicked. This requires determining the rectangle the Header control occupies, first. The Header Control is a child control of the ListView; as such, a platform Invoke using the EnumChildWindows() API was required, something like this:

private Rectangle _HeaderRect;
private delegate bool EnumWindowsCallBack(IntPtr hwnd,IntPtr lparam);
 [DllImport("user32.dll")]
private static extern int EnumChildWindows(IntPtr hwndParent,EnumWindowCallBack callbackFunction,IntPtr lParam);
 [DllImport("user32.dll"]
private static extern bool GetWindowRect(IntPtr hWnd,out RECT lpRect);

 [StructLayout(LayoutKind.Sequential)]
private struct RECT
{
    public int Left;
    public int Top;
    public int Right;
    public int Bottom;

}

private bool EnumWindowCallback(IntPtr hwnd, IntPtr lParam)
{
    RECT rct;
    if(!GetWindowRect(hwnd,out rct))
    {
    //first child of the listview should be the header control
    _HeaderRect=Rectangle.Empty; //likely the listview is not in Details mode, so there is no header control.
    }
    else
    {
        _HeaderRect = new Rectangle(rct.Left,rct.Top,rct.Right-rct.Left,rct.Bottom-rct.Top);
    }
    return false; //cancel enumeration.
}
private static ColumnHeader []  GetOrderedHeaders(ListView lvw)
{
    ColumnHeader []  returnarray = new ColumnHeader [lvw.Columns.Count] ;
    foreach(ColumnHeader loopheader in lvw.Columns)
    {
        returnarray [loopheader.DisplayIndex]  = loopheader;

    }
    return returnarray;
}

Quite a bit of boilerplate to add in. Basically, the idea is that we will hook the contextMenu Opening event of the Listview, (and we add a context menu to hook if the listview in fact doesn’t have one) in our constructor; and then when we receive the event we need to determine if the click occured within the area of the header control of the listview, if so, we cancel the event (which stops the default context menu from appearing) and show our own menu for the columnheader, which we can acquire using a bit of math and the static “GetOrderedHeaders” function, which retrieves the array of columnheaders of a ListView in order of appearance Left to Right (since the user could rearrange the Columns).

So First, we need to add code to the GenericListViewSorter’s Constructor. We also have a few private variables that are added; in this case, we need a ContextMenuStrip variable called “_ghostStrip” which we will use if we need to create a context menu for the control, since we don’t want that to appear in the default case. Of course we create our own ContextMenuStrip which we will show in the event instead of the default when appropriate. so we add this beneath the existing code in the constructor:

    if(handleListView.ContextMenuStrip==null)
    {
        handleListView.ContextMenuStrip = new ContextMenuStrip();
        handleListView.ContextMenuStrip.Items.Add("GHOST"); //add a ghost item so we get the Opening Event
        _ghoststrip = handleListView.ContextMenuStrip;
}

//create OUR context menu
_headerContextMenuStrip = new ContextMenuStrip();
//add a ghost item to make sure Opening will fire.
_HeaderContextMenuStrip.Items.Add("ghost");
handleListView.ContextMenuStrip.Opening += ContextMenuStrip_Opening;
handleListView.ContextMenuStripChanged += handleListView_ContextMenuStripChanged;

Of course we need to add the two referenced event handlers, too. The ContextMenuStripChanged being a rather simple implementation designed to keep changes in the contextmenu of the listview from causing us to balls up and stop showing ours (since we are now hooking a orphaned context menu not being shown by the listview).

void handleListView_ContextMenuStripChanged(object sender,EventArgs e)
{
    OurListView.ContextMenuStrip.Opening+=ContextMenuStrip_Opening;
}

Now the meat of the code is in the ContextMenuStrip_Opening() routine. This will need to determine wether its applicable to show the Column menu, or the already present menu (which it doesn’t show either if it happens to be the _ghoststrip). This is accomplished by use of the GetCursorPos() API routine paired with the already present GetWindowRect() implementation, which we update by calling EnumWindows.

void ContextMenuStrip_Opening(object sender,System.ComponentModel.CancelEventArgs e)
{
    //first, get screen coordinates of Cursor.
    POINTAPI gapi;
    GetCursorPos(out gapi);

    Point gotposition = new Point(gapi.X,gapi.Y);

    //acquire the HeaderRect of the control...
    EnumChildWindows(OurListView.Handle,new EnumWindowCallBack(EnumWindowCallback),IntPtr.Zero);
    //if the mouse position is within the retrieved rectangle, cancel the display of the normal menu and create and show ours.
    if(_HeaderRect.Contains(gotposition))
    {
        e.Cancel=true;
        int xoffset = gotposition.X - _HeaderRect.Left;
        ColumnHeader clickedheader = HeaderAtOffset(OurListView,xoffset);

        if(clickedheader != null)
        {
        //create the context menu as needed.
        _HeaderContextMenuStrip = new ContextMenuStrip();
        _HeaderContextMenuStrip.Tag = clickedheader;
        //two items, one for ascending order, one for descending order.
        ToolStripMenuItem AscendingHeaderItem = new ToolStripMenuItem(String.Format("Sort Column \"{0}\" Ascending",clickedheader.Text));
        ToolStripMenuItem DescendingHeaderItem = new ToolStripMenuItem(String.Format("Sort Column \"{1}\" Descending",clickedheader.Text));

        //if the current sort column is the header, check it off and disable it.

        if(CurrentSortColumn == clickedheader)
        {
            if(OurListView.Sorting ==SortOrder.Ascending)
            {
                AscendingHeaderItem.Checked=true;
                AscendingHeaderItem.Enabled=false;
            }
            else if (OurListView.Sorting==SortOrder.Descending)
            {
              DescendingHeaderItem.Checked=true;
              DescendingHeaderItem.Enabled=false;
            }   

        }
        AscendingHeaderItem.Tag = ClickedHeader;
        DescendingHeaderItem.Tag = ClickedHeader;
        //set event handlers for the two items.
        AscendingHeaderItem.Click+= AscendingHeaderItem_Click;
        DescendingHeaderItem.Click+= DescendingHeaderItem_Click;
        //add them to the context menu strip.
        _HeaderContextMenuStrip.Items.Add(AscendingHeaderItem);
        _HeaderContextMenuStrip.Items.Add(DescendingHeaderItem);
        //display the menu.
        _HeaderContextMenuStrip.Show(gotposition);
        }
   }
   else
   {
       //show the default menu, but only if it isn't the ghoststrip.
       if(OurListView.ContextMenuStrip == _ghoststrip)
           e.Cancel=true;

   }   

}

The events for the two buttons basically sort based on the columnheader in their tag, nothing particularly special there. the actual details can be seen in the source file itself, really.

It actually works quite well, I’m using it in a production application, and it’s working quite well.

Some obvious enhancements, of course, include making it possible to customize the shown menu, to present other options; perhaps a delegate or event that can be hooked that is given the Strip and the clicked column, and any number of other parameters? This would essentially give the equivalent of a ColumnHeaderRightClicked type event, too.

The Windows ListView: Sorting

BC_Programming — Thu, 22 Dec 2011 04:24:59 +0000

Anybody who has used windows is probably familiar with the ListView control. It is used in Windows Explorer; it is even used for the desktop. Heck, the ListView control even has implementations on Linux and Mac, and in the latter case it was there first.

The ListView itself can display in several modes. Normally, it shows things as Icons. But it can also be set to show Small Icons, a List, in some Operating Systems, there is a ‘Tile’ option, or even options like Large,Medium, and other sizes of Icons. My Personal favourite is the details mode.

HA! Bet you didn't expect me to use an image from Windows 95! Expect the unexpected, chaps.

Because I mostly see and use Listviews in Details mode, I also force people who use my software to deal with Details mode. Mostly because the reason I am displaying a ListView is to show some data in a somewhat tabular format and not just give them a few icons to drag around with minimal actual information, but I digress. Anyway, I think a good question at this point might be to look at what different parts this particular ListView has. First, the gray “buttons” at the top, which serve to title each column, are referred to affectionately as ColumnHeaders. Under each ColumnHeader there is data for a given “subitem” of each item. For example, the “Size” entry here is a Subitem for each drive. An interesting feature of columnheaders that is nearly universal is that you can click on one, and it will sort by that column.

Another interesting thing, is that in many programming environments, the ListView control doesn’t actually provide this feature for you, and you have to code it yourself. It is rather frustrating. In particular, Visual Basic 6 allows you to sort, but you can’t really customize what you sort by; it always treats it as text. In one of my VB6 applications, BCSearch (which is available for download from my Downloads page) I managed to use a Custom control, available from VBAccelerator.com, which exposes additional functionality of the ListView Control on top of that provided in either of the MS provided libraries for use within Visual Basic. One of these features is that it has better support for sorting. I still had to add my own “arrow” to show the sort direction, though.

BCSearch showing results sorted by Size

The VBAccelerator control exposes a number of events and properties for controlling sorting, which I use to properly sort the various subitems, so that various entries like date or size aren’t sorted as text.

Curiously, the .NET Windows Forms ListView control, while having more functionality, still leaves a lot of effort to the programmer for what ideally ought to be a free feature supported by the OS. In fact it IS a free feature supported by the OS. Thankfully, the .NET control does in fact provide a feature for customizing sort functionality, And all you need is a class to implement IComparer. the IComparer will be used to compare the listitems as the Listview sorts. But if you have, say, Date and Time fields and size fields or other fields that can’t just be sorted as text, you are going to need to implement your own special comparer for each. This amounts to quite a bit of glue code; on top of that, you will need to handle the ColumnClick events on the ColumnHeader, change the sort mode, and sort it, and so forth.

To combat this bloating code, I wrote a relatively small class designed to encapsulate sorting. The idea being that you create a instance of this class for each listview, pass in the ListView to it’s constructor, and the class handles all the details. It worked quite well. There was a minor issue that amounted to a gigantic pain in the ass but at the same time made the result a lot better.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
namespace JobClockAdmin
{
public static class ListViewExtensions
{
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
public struct HDITEM
{
public int mask;
public int cxy;
[System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPTStr)]
public string pszText;
public IntPtr hbm;
public int cchTextMax;
public int fmt;
public IntPtr lParam;
// _WIN32_IE >= 0×0300
public int iImage;
public int iOrder;
// _WIN32_IE >= 0×0500
public uint type;
public IntPtr pvFilter;
// _WIN32_WINNT >= 0×0600
public uint state;
[Flags]
public enum Mask
{
Format = 0×4, // HDI_FORMAT
};
[Flags]
public enum Format
{
SortDown = 0×200, // HDF_SORTDOWN
SortUp = 0×400, // HDF_SORTUP
};
};
private const int HDM_FIRST = 0×1200;
private const int LVM_FIRST = 0×1000;
private const int HDM_GETITEMCOUNT = (HDM_FIRST + 0);
private const int HDM_SETITEM = (HDM_FIRST + 4);
private const int LVM_GETHEADER = (LVM_FIRST + 31);
private const int HDM_GETITEM = (HDM_FIRST + 3);
[DllImport("user32.dll", EntryPoint = "SendMessageA")]
private static extern IntPtr SendMessage(IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);
[System.Runtime.InteropServices.DllImport("user32.dll", EntryPoint = "SendMessage")]
public static extern IntPtr SendMessageHDITEM(IntPtr hWnd, uint Msg, IntPtr wParam, ref HDITEM hdItem);
public static void SetSortIcon(this System.Windows.Forms.ListView ListViewControl, int ColumnIndex, System.Windows.Forms.SortOrder Order)
{
IntPtr ColumnHeader = SendMessage(ListViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int ColumnNumber = 0; ColumnNumber < = ListViewControl.Columns.Count – 1; ColumnNumber++)
{
IntPtr ColumnPtr = new IntPtr(ColumnNumber);
HDITEM item = new HDITEM();
item.mask = (int)HDITEM.Mask.Format;
SendMessageHDITEM(ColumnHeader, HDM_GETITEM, ColumnPtr, ref item);
if (!(Order == System.Windows.Forms.SortOrder.None) && ColumnNumber == ColumnIndex)
{
switch (Order)
{
case System.Windows.Forms.SortOrder.Ascending:
item.fmt &= ~(int)HDITEM.Format.SortDown;
item.fmt |= (int)HDITEM.Format.SortUp;
break;
case System.Windows.Forms.SortOrder.Descending:
item.fmt &= ~(int)HDITEM.Format.SortUp;
item.fmt |= (int)HDITEM.Format.SortDown;
break;
}
}
else
{
item.fmt &= ~(int)HDITEM.Format.SortDown & ~(int)HDITEM.Format.SortUp;
}
SendMessageHDITEM(ColumnHeader, HDM_SETITEM, ColumnPtr, ref item);
}
}
}
class GenericListViewSorter : IComparer
{
private System.Windows.Forms.ListView OurListView;
//GetCompareValue: given a columnname and a ListViewItem, should return any more specific type.
//For example, if Column represents a date value, it would return a DateTime.
public delegate Object GetCompareValue(GenericListViewSorter Sorter, String ColumnName, ListViewItem Item);
private GetCompareValue CompareValueFunc;
private ColumnHeader CurrentSortColumn = null;
private SortOrder [] SortOrders = new SortOrder [] { SortOrder.None,SortOrder.Ascending, SortOrder.Descending };
private String [] SortOrderImageKey = new string [] {"CLEAR","ASCENDING","DESCENDING" };
private int CurrSortIndex = 0;
private Object GetCompareValue_Default(GenericListViewSorter Sorter, String ColumnName, ListViewItem Item)
{
//default just returns the String, for now. Later, add special conditions that detect when something is a valid date. Or something…
int indexuse = Sorter.OurListView.Columns [ColumnName] .Index;
return Item.SubItems [indexuse] .Text;
}
public GenericListViewSorter(ListView handleListView,GetCompareValue GetCompareRoutine)
{
OurListView = handleListView;
if (GetCompareRoutine != null)
CompareValueFunc = GetCompareRoutine;
else
CompareValueFunc = GetCompareValue_Default;
handleListView.ColumnClick += new ColumnClickEventHandler(handleListView_ColumnClick);
}
void handleListView_ColumnClick(object sender, ColumnClickEventArgs e)
{
//throw new NotImplementedException();
//First thing is first: is this the same column that was clicked before?
ColumnHeader clickedcolumn = OurListView.Columns [e.Column] ;
if (CurrentSortColumn == null)
{
CurrentSortColumn = clickedcolumn;
}
if (CurrentSortColumn != clickedcolumn)
{
//if not, set the current sort Index to 0…
// CurrentSortColumn.ImageKey = "CLEAR"; //don’t want it to keep the image…
CurrentSortColumn = clickedcolumn;
}
else
{
//if it is the same, increment it and take the modulus…
CurrSortIndex = (CurrSortIndex + 1) % (SortOrders.Length);
Debug.Print("CurrSortIndex:" + CurrSortIndex);
}
//CurrentSortColumn.ImageKey = SortOrderImageKey [CurrSortIndex] ;
OurListView.Sorting = SortOrders [CurrSortIndex] ;
OurListView.SetSortIcon(CurrentSortColumn.Index, OurListView.Sorting);
if (CurrSortIndex == 0)
{
OurListView.ListViewItemSorter = null;
}
else
{
OurListView.ListViewItemSorter = this;
}
OurListView.Sort();
}
#region IComparer Members
public int Compare(object x, object y)
{
ListViewItem a = (ListViewItem)x;
ListViewItem b = (ListViewItem)y;
String columnnameuse = CurrentSortColumn.Name;
Object checkA = CompareValueFunc(this, columnnameuse, a);
Object checkB = CompareValueFunc(this, columnnameuse, b);
if((checkA is IComparable) && (checkB is IComparable))
{
if(OurListView.Sorting==SortOrder.Ascending)
return ((IComparable)checkA).CompareTo(checkB);
else
{
return ((IComparable)checkB).CompareTo(checkA);
}
}
return 0;
}
#endregion
}
}

As you can see, it it relatively small (overall). the API code at the top might be a bit confusing, but it is a result of what can only be described as an oversight on Microsoft’s part; see, originally, I was changing the sort arrow header by simply changing the columnheader image. This worked, sorta of, but there was no way to remove the image and it had this weird effect where it would basically move the text and make it aligned sorta weird. Turns out that the way the ListView would “normally” show sort order icons was a built in feature of the Listview since Common Controls 6 (XP). After some SDK digging I was able to use the Platform Invoke feature of C# to call all the appropriate API functions and “force” the Listview to show the sort order in the header appropriately.

The class also exposes a custom delegate which can be implemented and passed in to the constructor, which will allow for “custom” sorts. This is useful if columns contain data like dates, or numbers that you don’t want to be sorted using the normal “text” comparison.

All in all, It’s a class I’ve added to my “toolbox”, alongside my INIFile class for accessing INI Files. did I write about that one? I forget.

USB Notification Sounds

BC_Programming — Fri, 16 Dec 2011 20:10:56 +0000

Most Computer users are familiar with the Sounds that Windows emits when you plug and unplug a USB thumb drive. It’s a useful form of auditory feedback that the drive was in fact detected. However, I’ve found linux to be oddly tacit in this regard. So I set to work writing a python script that uses DBUS to monitor for new USB devices and will play a sound whenever a new Volume is attached.

#!/usr/bin/python
#by BC_Programming
import dbus
import gobject
import time
import subprocess
print "BASeCamp ‘USBSounds’ Simple USB Volume notification sound."
#playsound merely shells out to mplayer. I would have preferred an integrated solution but… meh.
def playsound(soundfile):
subprocess.call( ["mplayer", "hardwareinsert.wav"] , stdout=open(‘/dev/null’, ‘w’), stderr=open(‘/dev/null’, ‘w’))
class DeviceAddedListener:
def __init__(self):
#get the system bus…
self.bus = dbus.SystemBus()
#get the manager
self.hal_manager_obj = self.bus.get_object(
‘org.freedesktop.Hal’,
‘/org/freedesktop/Hal/Manager’)
#get the interface for the manager
self.hal_manager = dbus.Interface(self.hal_manager_obj,‘org.freedesktop.Hal.Manager’)
#connect to the appropriate signals.
self.hal_manager.connect_to_signal(‘DeviceAdded’, self._filteradd)
self.hal_manager.connect_to_signal("DeviceRemoved",self._filterremove)
#note: I couldn’t get DeviceRemoval sounds to work since it doesn’t let you #inspect whether the removed device is a volume via "QueryCapability"… since it’s gone.
def _filteradd(self, udi):
device_obj = self.bus.get_object (‘org.freedesktop.Hal’, udi)
device = dbus.Interface(device_obj, ‘org.freedesktop.Hal.Device’)
#if it is a volume, call the do_add function…
if device.QueryCapability("volume"):
return self.do_add(device)
def _filterremove(self,udi):
try:
#device_obj = self.bus.get_object(‘org.freedesktop.Hal’,udi)
#device = dbus.Interface(device_obj,’org.freedesktop.Hal.Device’)
#if device.QueryCapability("volume"):
# return self.do_remove(device)
except:
return
#unused….
def do_remove(self,volume):
playsound("hardwareremove.wav")
#displays some info about the added device to the console (maybe future changes can pop stuff like volume label, device file, size, etc into a Notification box?)
def do_add(self, volume):
device_file = volume.GetProperty("block.device")
label = volume.GetProperty("volume.label")
fstype = volume.GetProperty("volume.fstype")
mounted = volume.GetProperty("volume.is_mounted")
mount_point = volume.GetProperty("volume.mount_point")
try:
size = volume.GetProperty("volume.size")
except:
size = 0
print "New storage device detected:"
print " device_file: %s" % device_file
print " label: %s" % label
print " fstype: %s" % fstype
if mounted:
print " mount_point: %s" % mount_point
else:
print " not mounted"
print " size: %s (%.2fGB)" % (size, float(size) / 1024**3)
#and play a sound.
playsound("hardwareinsert.wav")
#main loop…
if __name__ == ‘__main__’:
from dbus.mainloop.glib import DBusGMainLoop
DBusGMainLoop(set_as_default=True)
loop = gobject.MainLoop()
print "in __main__…"
DeviceAddedListener()
loop.run()

As can be seen, it’s a tad messy, and even rather hackish. For one thing, it uses DBUS, which to my understanding is deprecated. Unfortunately, the replacement I couldn’t really get a clear answer on. From what I can gather, the proper method for now is libnotify and pynotify, but I couldn’t get libnotify to compile and thus was not able to properly use pynotify, and I didn’t want to have to force people to go through that sort of hell when they tried to use my script, so I stuck to DBUS.

The only limitation I discovered is that on device removal, you can’t really inspect what device was removed. At first I just figured, Just play the sound everytime and let the user figure it out, but for some reason that just assaulted me with constant device removal sounds. So I ended up commenting (and I think removing) that particular segment of code.

Playing Sounds is unnecessarily difficult in Python, or more specifically, Linux. It’s ridiculous. First I found a build in module for python, ossdevsound (or something to that effect), but attempts to use that failed because apparently it uses OSS, which apparently was replaced by ALSA for whatever reason. So I tried pygame, which errored out that I had no mixer device when I tried to initialize the mixer. So I decided to hell with it and just spawned a mplayer process, and redirected it’s stdout to NULL to avoid the nasty business where it barfs all over the console. And amazingly, that seems to work fine for device insertions, which I decided I was content with.

By default I use the Windows insertion and removal sound files. The removal sound isn’t actually used but I kept it in the g-zipped tar because I wanted to. Personally I usually just launch this in a terminal and then tuck it away on another desktop. No doubt one can execute it as a daemon or something instead and get the functionality without the console window baggage to keep around, though.

ThumbNotify.tar.gz

Linux App Gem: ejecter

BC_Programming — Fri, 16 Dec 2011 19:51:33 +0000

One feature of windows that I often miss while using My Linux laptop is the ability to eject USB drives from the system tray. With my Linux Mint 10 install (and likely newer versions, and of course other distros) you typically need to minimize everything to get to the desktop (or of course use the shortcut, but you still need to minimize everything) get to the icon, right click it, choose to eject it, etc. With windows, you simply Left-Click on the icon in the Notification area and click the drive to remove.

Thankfully, It turns out there is a very cool and unassuming little program that provides this exact functionality. It is called “ejecter”.

Without dwelling on the fact that it really ought to be called Ejector, the program does exactly what it says on the tin. When you plug in a USB drive, the icon appears on the system tray.

Ejecter's ejection tray flyout. Or menu.

As can probably be guessed, this is exactly the type of functionality I needed. You can see exactly what the product looks like in the image to the left; when you left-click the icon, a little tray pops out (some might call it a menu, I suppose) and lists the connected USB drives that can be “Safely removed”. I rather like how it shows the Volume name as well as the name of the device itself, which helps prevent confusion. Ejecting the device entails clicking the Eject button to the right of the device you want to eject. Two clicks and you’re done!

It’s very simple to install, to- it’s in the repository of most distros; usually it’s a quick sudo apt-get install ejecter or the equivalent command (I remember yum but not the syntax). It works on GNOME, but I’m not sure if it works with KDE, or any other Desktop environment, for that matter.