List<Position> result;

 // insert the questions into a structure to make them easy to search

 while ((line = data.ReadLine ()) != null) {

   string[] words = line.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);

   wordPosition = 0;

   foreach (string word in words) {

     if ((result = noSig.Find(word)).Count != 0)

       significant = true;

     else

       significant = false;

     Position p = new Position (lineCount, wordPosition++, significant);

     wordTree.Add (word, p);

   }

   lineCount++;

 }

You have to understand that I’ve been programming a long time (the first program I wrote I had to flip the toggle switches on the front panel to toggle in the 0’s and 1’s), but just about everything I’ve done has been command line based. Mostly utility programs, programs that operate behind the scenes, programs that are used by other developers or systems people – in short, nothing graphical in nature. This is a whole new issue for me.

So, of course,  the first thing you do is hit Google, or the C#/GTK# pages looking for a tutorial on how to do this. I found a problem here – there are a lot of tutorials, but they’re relatively static. That is, they show how to put a button and a text display on a page, press the button and update the text display. Those tutorials work, but they don’t expand well.

I’m working on programs that put up a display, take some input, and then go off and do some work. This work is supposed to give feedback to the user so they know what’s happening. The tutorials I found don’t do that.

Thus was born this tutorial in which I use Glade# to develop the interface and then use GTK# to run a simple little program that picks a number between 1 and 10,000 and then tries to determine what that number is. While it’s guessing, it’s updating the GUI to show the current guessed number and how many guesses it’s taken so far.

I don’t claim that this is extensible to the most complex program, it’s worked for this tutorial and now I’m off to implement this method in a larger program to see how well it works there.

I’ve included links to a MonoDevelop and a VS2005 solution. Please download and give them a try. Feedback is most welcome.

Hopefully someone will find this useful.

MonoDevelop Solution for the tutorial

VS2005 Solution for the tutorial

“A command line? What’s that?”  you might ask. I understand that most of the programs you run always start up with a GUI that you can then use to set up all your parameters. This is not always the Right Thing to do. A lot of what I program are utility programs that do things to files in a scripted (or batch) mode. GUIs, in this case, just get in the way.  Thus the command line – you tell the program what to do when you start it up and it never talks to you again.

For example:

 playMP3 --directory /myhome/music --background true

The convention is that a long name option has two preceding – (dash) characters and a short name option (a single character) has a single preceding dash character.

There are certainly a lot of options out there for doing this sort of thing, but I can be sort of an odd person – if I’m using a language, I want to use the language;  not write in a language I’m comfortable in and just use the syntax of the new language.

That may be a difficult concept to visualize if you’re not a programmer. Hopefully someone can comment and give an example in the non-programming world, but I can give a programming example. I once worked with a programmer that had done most of his work in COBOL and he was very good at it. Times change, and he needed to be programming in C. C is not like COBOL at all. It is, after all, meant to do different things.This person wrote C programs and they compiled and they worked

However, one look at his source and you could tell that his mind was still writing COBOL. He wasn’t taking advantage of many of the features that C has and the program was structured as if it were in COBOL. He got the job done, but it could have been done better.

So, to get back on track, I was looking for an assembly that could do command line processing that externally looked like all the other command line processing I was familiar with, but internally it was written as a C# program.

I searched Google and found a lot of candidates, but one named Command Line Parser Library seemed to fit the bill very well. I downloaded and compiled it, sorted out the documentation, and started using it.

Well, I’m an iterative developer and as I expanded the utility program I was writing I found that this particular assembly was not capable of doing one thing I needed it to do. No worries, there are a lot of choices out there so I went back to Google and did some more looking. I found that the assembly I was already using really was easy to use and was so close to being what I needed that I contacted the author and talked to him about it.

He asked me to make an entry on the web site and he’d try to sort out how to accomplish what I needed. He already had a similar feature, used for trailing arguments, but I needed to be able to do things just a bit different. If he didn’t have the time and/or inclination to add this feature then I was prepared to delve in to the code to add it myself.

However, just today he released a new version with my feature added. Very cool.

He apologized for it taking so long, but since I knew he was working on it, the time it took hadn’t bothered me. Not having this feature hadn’t been holding me up because I  had a lot of other development to work on. Now I can go back and update the code and take advantage of this newly added feature.

Why am I blogging about this? Just because I think it’s important to acknowledge that a substantial amount of good work is going on in the small development shops. If he’s like me (and it sounds like he is) the definition of “development shop” is him sitting in front of his computer in the basement or spare room whenever you have the time to work on writing code for fun. He’s not getting paid for this, he’s scratching an itch and that’s something I can identify with.

I spent a lot of Saturday and Sunday trying to sort out how to do the configuration in an easier manner than the original writer and was having a lot of difficulties sorting it out. I finally found something called Nini that is working just fine.

So, I still have to tie changes in the UI back to the configuration file and then forklift the code from the original project into this one. I started a new project because a) I wanted a slightly different name, and b) it was easy to keep the original, working code separate from my changes.

I ran across a couple of open source Windows installers so, hopefully, by the end of the week I’ll have this ready to distribute.

When I finally got that straight in my head, I decided to integrate the two programs in to one. I think the original thought was that the actual resizer was meant to be a command line sort of thing and there wasn’t a need for a user interface. Since it always opened up some sort of a dialog to tell you what it had done or to ask a question or two, I decided that making it a graphical program from the start would be OK.

So, I fired up the interface editor and came up with this:

The one thing that’s not correct yet is the Max Size element. Obviously we don’t want fractional sizes. I think that’s a setting in the widget, but I’m not quite there yet. That is the next step, tieing the new interface to the existing code.

One thing that might not be evident from that screenshot is that the bottom element is a status bar, in which the user will see the images fly by as the resizer works.

Thoughts? Does it look OK?  GUI design is definitely not my strong point, so I won’t be offended by people that want to make it more usable.

Stay tuned.

I’ve recently gotten involved with a group called <a href=”http://eons.com” target=”_blank”>Eons</a>, a website that’s targeted toward the over 50 folks. I’m involved in the Better Photography group, and the subject came up about someone’s image being “borrowed” by a different person without permission.

So, I went off the to web to look for some sort of utility that would be able to resize and watermark images. I found a resizer program (named, appropriately enough, Resizer) and an article on creating both image and text watermarks. The Resizer program was up for adoption as the person who wrote it was no longer interested in maintaining it. He had written it for a specific purpose and the program was no longer needed.

I contacted him about adopting it and after the appropriate conversations, he passed it on to me. I added three features to it (reduced DPI, image watermarking, text watermarking) and it’s now working. I don’t have it available for download quite yet as it’s currently set up as two separate programs – one to edit the config, one to resize images. In the process of fixing the config I came to the conclusion that I needed to integrate the two programs as I don’t want to plot pixels to place items on the dialog by using pixel counts.

One other thing that prevents me from putting up at the moment is that it’s a .NET program (and yes, it runs on both Windows and Linux) but I don’t have a good install for it yet. I have a link or two to investigate for an install program, but I’ve not quite gotten that far.

All that being said, if you have .NET installed on your Windows or Linux box and don’t mind a little hand-editing of the config file, then drop me a line and I’ll zip up the two programs for you to try out.

Right now he has the confidence in me that I don’t (yet.)  I’m just having a hard time getting started. The first chapter is all about getting set up. Since the book is about coding you have to have some tools installed to get working.

Since I’ve already been annoyed at books and articles that say “Here’s what I’m using, if you don’t use this you’re on your own”and I’m writing a platform independent How-To, I feel as if I at least need to show how to set up the environment for the two primary platforms: Windows and Linux.

The problem is this: I’m not the expert on Windows and I have to find a Windows box that doesn’t already have some sort of Visual Studio installed on it already. I should have the virgin Windows box resolved as my work desktop is dual boot system and it’s only been booted into Windows once. It just means that I have to pay very close attention to the steps involved in downloading and installing the free version of VS.

Also, in the book, do I use screen shots? After all, it’s a web page, so it’s subject to change at any time and having pictures of something that doesn’t exist isn’t very helpful. But without pictures, what do I call those areas on the screen?  Since the free versions of VS are targeted to a specific language, the page they show has separate visual areas for each of the choices (VC#, VB, VC++, etc) and you pick your “natural language” (English, Chinese, etc) and then it starts the download.

I just don’t have the terminology to describe what to do on that page.

My mentor says that I should be targeting the book to beginning to intermediate programmers. I don’t have an issue with that, but it’s been a long time since I was a beginner so how detailed do I make the installation instructions? How much do I presume they do (or should) know, and at what point is what they need to do outside the scope of the book?

I really think this will all get easier (hey, you in the back,  stop laughing) as I go on and I start to get a feel for how it all goes together.

Stay tuned, hilarity is sure to ensue.

I’m currently working on a couple of .NET projects. The first is to instantiate a rendition of a galaxy by using the rules for creating a planetary system using the rules found in Universe, a RPG originally created by SPI.

I pretty much have the code written to create a galaxy and I just need a way to display it to ensure that all those numbers actually turn out to create nice systems and to have some visual feedback on how they look.

In order to do that, I’m working on the next (and parallel) project. I have a book that creates a 3D engine based on OpenGL. I am, in essence, translating that in to C#. It’s interesting to see what sort of things people who code in C/C++ do and assume.

I know, I used to be one of them :)

The most difficult thing to “translate” is the assumption that anything can be a stream of bytes. For example, reading the header of an archive file in the author’s code is just, essentially,

struct header {char sig[5]; int major; int minor;} h;
fread(&h, sizeof(h), fp);

This causes a problem in C# – mainly because pointers aren’t safe code. So I end up reading the header an entity at a time. *And* I have to account for padding.
There’s an extra 3 bytes after the sig because ints have to be on a 4 byte boundary.

Thus I’ve created version 2 of the archive file that will treat it a bit differently. I can still read the old format, but if any changes are made it will write a new format file.

At any rate, once I have a display system for the galaxy then I can worry about how to evolve this into a game.

Next time (which should be a few months sooner that the lag between these last two posts) I’ll post up what tools I’m using to build this stuff. It’s just that it’s at home now and I’m stealing time from work to post this up.

I do have to wonder, however, why some people have to make things so difficult.

So, it turns out that if I look for a tutorial on just plain GTK then it’s easier to find what I’m looking for. On first blush it’s not all that easy to design a form using GTK. There are a lot of fiddly bits to get all lined up to make it work.

Now, I’ll admit right here that I’m not at one with graphical design (using graphical tools to create things) but to my way of thinking there is a lot of non-intuitive stuff going on.

When I first tried putting a menu on the form, I dragged it on and it promptly expanded to be full size – it took up the entire window. Now, that might be OK if the new object was resizable, but it’s not. It turns out that you need containers for all your widgets. This just seems counter-intuitive to me, but now that I know (or at least have an idea of) how it works, I’ll give using GTK another shot. I had switched back to using Windows Forms for a couple of reasons. The first, of course, is that the GTK version wasn’t making sense. Secondly, I’ll give the designers at Microsoft kudos for how they implemented their stuff. It is much simpler and straight forward to implement than the folks at GTK came up with. Thirdly, since this is meant to be a cross platform application I wasn’t sure I wanted to mess around with adding a GTK requirement for the Windows folks.

I don’t know enough yet about distributing ECMA 334 applications yet, so that last point my be a non-issue. Far more important, to me, is the ease of programming. Especially as GTK seems so convoluted. I’ll try an example here to show you.

Windows Forms

public class RSSMenu : MainMenu
{
MenuItem miFile;
MenuItem miFileOpen;
MenuItem miFileClose;
MenuItem miFileExit;

public RSSMenu()
{
miFile = new MenuItem("&File");
MenuItems.Add(miFile);

miFileOpen = new MenuItem("&Open");
miFileClose = new MenuItem("&Close");
miFileExit = new MenuItem("&Exit");

miFile.MenuItems.Add(miFileOpen);
miFile.MenuItems.Add(miFileClose);
miFile.MenuItems.Add(new MenuItem("-"));
miFile.MenuItems.Add(miFileExit);

miFileOpen.Click += new EventHandler(miFileOpen_Click);
miFileClose.Click += new EventHandler(miFileClose_Click);
miFileExit.Click += new EventHandler(miFileExit_Click);

}

public void miFileOpen_Click(object sender, EventArgs e)
{
}

}

Note how easy it is to add items to a menu and event handlers to the widgets.
GTK

menu = gtk_menu_new ();

/* Next we make a little loop that makes three menu-entries for "test-menu".
* Notice the call to gtk_menu_shell_append.  Here we are adding a list of
* menu items to our menu.  Normally, we'd also catch the "clicked"
* signal on each of the menu items and setup a callback for it,
* but it's omitted here to save space. */

for (i = 0; i < 3; i++)
{
/* Copy the names to the buf. */
sprintf (buf, "Test-undermenu - %d", i);

/* Create a new menu-item with a name... */
menu_items = gtk_menu_item_new_with_label (buf);

/* ...and add it to the menu. */
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);

/* Do something interesting when the menuitem is selected */
g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
G_CALLBACK (menuitem_response),
(gpointer) g_strdup (buf));

/* Show the widget */
gtk_widget_show (menu_items);
}

/* This is the root menu, and will be the label
* displayed on the menu bar.  There won't be a signal handler attached,
* as it only pops up the rest of the menu when pressed. */
root_menu = gtk_menu_item_new_with_label ("Root Menu");

gtk_widget_show (root_menu);

/* Now we specify that we want our newly created "menu" to be the menu
* for the "root menu" */
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);

/* Create a menu-bar to hold the menus and add it to our main window */
menu_bar = gtk_menu_bar_new ();

gtk_widget_show (menu_bar);

/* Create a button to which to attach menu as a popup */
button = gtk_button_new_with_label ("press me");
g_signal_connect_swapped (G_OBJECT (button), "event",
G_CALLBACK (button_press),
G_OBJECT (menu));

gtk_widget_show (button);

/* And finally we append the menu-item to the menu-bar -- this is the
* "root" menu-item I have been raving about =) */
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);

/* always display the window as the last step so it all splashes on
* the screen at once. */
gtk_widget_show (window);

The GTK code came from a tutorial located at http://www.gtk.org/tutorial/x1579.html. Note that I am not criticizing his programming techniques here, just contrasting the two methods.

The book is [i]Practical Mono[/i] by Mark Momone (APress) and the application is an RSS reader. This is application useful to me because I should be able to modify it to store the feeds in a common place on my server. Currently I’m using Thunderbird to read the RSS feeds I’m interested in, which works fine, but since the RSS info is stored locally I have to coordinate which things I’ve read where, etc. Having a common storage area would alleviate this problem.

OK, now that you have the background here’s my beef: The book uses System.Windows.Forms (that’s fine) but I want to use GTK#. In order to create the menus for the application the book puts it all in code. Any tutorials that reference creating menus using GTK# want me to use the graphical tool to do that.

I’m minimally competent in using designer interfaces. Actually, using the word “minimally” might be giving myself too much credit. My brain just doesn’t work that way. Simple stuff I’m OK with. I’m using MonoDevelop for the application work and I can muddle through that OK. But grab a picture of a control and put it on a page and then edit it? I just don’t see it.

As an aside, I was in some sort of “play nice with others” training at work (and got in trouble for stating that “sometimes I think other people are idiots because they are”, but never mind that) and the instructor used a bit of video tape with MLK’s “I have a dream” speech. After she was done with the clip, she was talking about how the words he used invoked a visual response. I told her that it didn’t for me. Yes, the words were inspiring, but I didn’t see pictures in my mind. Turns out everyone else did. I think this is just another aspect of my having issues with what appears to me to be complicated visual cues.

Oh, and I get my daughter to use The Gimp/Photoshop to fix up images for me. If it’s more than cropping or changing the size I just don’t get it. All those layers? Just more opportunity for me to get lost in a maze of twisty little passages, all alike.
Am I the only person left who wants to write code instead of using drag and drop? I’ve wondered if it’s just something built into my brain or if all those years of only having a command line have ossified my brain paths into ruts that I can no longer see out of as I wander down the aisles of new development.