Atalasoft Community

Beauty is only Skin-Deep: Skinning your WinForms Application

jacobl — Fri, 09 May 2008 15:00:00 GMT

We all want our Windows applications to stand out, and I think most people would like to believe that there are a few distinct approaches to achieving this. You can either have an app that does great things, one that does things great, or one that does things while looking great. The ideal approach is to combine all three and make great applications that do things very well while looking amazing. The first impression is everything, right? So this post is all about how to skin your application. While I can't turn you into Monet, I can show you what a paint brush looks like.

Eat Your Cake Without Having to Wait for Your Oven to Preheat

There are toolkits out there that allow you to skin your apps very easily like DotNetSkin or Sunisoft's IrisSkin, but most of them cost money and all you might want to do is change a few things without overhauling everything that is Windows UI.

Replacing Your Lamp Because Your Light Bulb Burnt Out

Alek Trebec - "Answer: All the things that make windows behave like windows."

Contestant - "What are 'things I took for granted'?"

Just a forewarning: you are opening somewhat of a can of worms here; albeit a small one. When you skin an app, there will be many things that you got for free before but will now have to do yourself. Window-close, -minimize, and -maximize are gone but easy enough to correct.

Window dragging requires a little bit of finesse and window resizing requires a bit more. I'll explain all that with sample code below, but first, let's talk about getting rid of that awful XP-blue menu-bar.

Removing the Menu-Bar

After you have your project set up and are looking at your form in design-time. Open the Properties pane form the main form object. Here, you need to find the Appearance labeled "FormBorderStyle". Change it from "Sizable" to "None". You will notice that in the design, your top menu bar and the border of the window are now gone! Excellent, a clean slate.

Readding Basic Window Controls

You can add all or none of these, but I suggest (for the sake of your users) that you at least add a close button. Here's what you do.

Create a button in the upper right hand corner of your form; the location is by convention, you can put it anywhere you'd like of course. Change the name of the button to closeButton and double-click it so that Visual Studio brings you to the code view and creates you a OnClick event handler. Add the following code to it:

private void closeButton_Click(object sender, EventArgs e) { Application.Exit(); }

Very simple.

Minimize

Create another button on your form and change its name to minButton. Double click it to open code view to its OnClick event handler. Add the following code to that one:

private void minButton_Click(object sender, EventArgs e) { WindowState = FormWindowState.Minimized; }

Maximized / Normal

There are two ways to do a "Maximize" button because you either have to change the button after it is maximized to a "Normal" button or you have to make the button's label generic enough that the one button can be used for both tasks. To keep things simple, we will do the latter.

Create a button and change its name to maxNormButton and double click it like the last two examples. Add the following code to your event handler:

private void maxNormButton_Click(object sender, EventArgs e) {

if (WindowState == FormWindowState.Maximized) { WindowState = FormWindowState.Normal; } else { WindowState = FormWindowState.Maximized; } }

I will leave creating that generic-enough label up to you because I can't really think of anything right now. How about a ~ (tilde). That's never used enough.

Moving that Window Around

To move your window around, you will need to handle the mouse down event as well as the mouse move event. We'll have to do some simple math to determine the offset from where the mouse was clicked to where it is after it has moved. But before we can do anything with that, we need to add something to the form to grab on to.

You can either add a PictureBox or a Panel to your form. If you're looking to put something other than a solid color in the area, you'll want to go with the PictureBox, otherwise just drop a simple Panel up there and change it's BackColor property to something other than Control-gray. I will be using the Panel in this example.

Add a Panel to your form and stretch it the length of your form placing it along your top edge. You can even Dock it on the top if you'd like, but if you want to add rounded corners, you wont want to do that. Change the name of the panel windowbarPanel.

Right click on your form and choose View Code. We need to capture when the user mouses down on your menu bar. Add a MouseDown event handler to the constructor of your form.

windowbarPanel.MouseDown += new MouseEventHandler(CaptureMouseDown);

The function that will handle the event, void CaptureMouseDown, needs to save the mouse's position relative to your form's upper left hand corner. And it should only do this if the left mouse button is pressed. Create a private member variable _OffsetPoint of type Point to store your mouse position in. In the end, it should look like this:

void CaptureMouseDown(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) _OffsetPoint = new Point(e.X, e.Y); }

Next we need to handle when the mouse is moved. Add a MouseMove event handler to the constructor of your form.

windowbarPanel.MouseMove += new MouseEventHandler(MoveWindow);

The function that will be handling this event, void MoveWindow, needs to offset the mouse's new position against it's MouseDown one and set the location of the window to that point. Again, only if the left mouse button is being pressed. Here it is:

void MoveWindow(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { Point mousePos = Control.MousePosition; mousePos.Offset(-_OffsetPoint.X, -_OffsetPoint.Y); Location = mousePos; } }

Save it and build it and you've got yourself a form that doesn't have traditional Windows form borders but behaves a lot like one! Now, if only we could resize this thing...

Resizing It

In traditional WinForms, you can grab any edge of a window and resize it. That's more than I want to get into in this post, so I'll only go over resizing your form from the lower left hand corner of the screen.

In design-view, create a Panel in the lower left making it the size of your desired click area. Mine is about the size of an eraser head. Name it resizePanel.

In code-view, you need to capture the position of the mouse relative to the screen with a mouse down event handler and save the current size of the window. You'll have to create new member variables for the window's width and height (they're of type int) but we can reuse the _OffsetPoint from before since you can't resize and move a window at the same time. In the constructor of the form, add the following:

resizePanel.MouseDown += new MouseEventHandler(CaptureMousePosition);

The CaptureMousePosition method should look like this:

int _Width; int _Height; void CaptureMousePosition(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { _Width = Width; _Height = Height; _OffsetPoint = new Point(Control.MousePosition.X, Control.MousePosition.Y); } }

Next, we need to set the width and height of the window every time the MouseMove event is fired. Add the following line to your form's constructor:

resizePanel.MouseMove += new MouseEventHandler(ResizeWindow);

The ResizeWindow method needs to figure out how far the mouse has moved and apply that to the width and height of the form. It should end up looking like this:

void ResizeWindow(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { Point mousePos = new Point(Control.MousePosition.X, Control.MousePosition.Y); mousePos.Offset(-_OffsetPoint.X, -_OffsetPoint.Y); Width = _Width + mousePos.X; Height = _Height + mousePos.Y; } }

That's about it. It could definitely use some work, but it's a great start.

Just to Recap

With the information above, you can now create applications that have custom border elements. We had to rewrite the most basic window functions, but that's OK. It wasn't that painful. I hope to see better-looking WinForm applications from all of you. The only piece that's up to you is embedding beautiful Photoshopped graphics for all of your buttons and borders.

Update

I've added some pictures that go along with the process. Also, here are a few notes about anchoring your new elements correctly. If you don't correctly anchor, your resizing will not work correctly.

Your close, minimize, and maximize buttons should be anchored to the upper right. Your windowBarPanel should be anchored to the left-top-right so it stretches accordingly. Lastly, your resizePanel should be anchored to the bottom right so that it moves with your mouse as you resize.

Here's a sample project that does everything we've talked about in this blog:

SkinFormsBlog.zip

Cloudscape Wallpaper Generator

kvwtrav — Fri, 09 May 2008 10:04:00 GMT

Welcome to the ninth of 31 applications we will post (in addition to the contest participants' submissions). Make sure you add this blog to your RSS / Atom feed and check the gallery for summaries of all the apps as they are released.

This application demonstrates how to combine various DotImage commands to create an image of a skyline. The process for drawing the clouds is based on this Hugo Elias description.

To use this application, click Create Cloudscape to preview the generated image. Once the image is loaded you can simply click Set as Wallpaper to set as your desktop wallpaper. Your wallpaper will be randomly generated and totally unique.

Download the installer.

Download the source.

Linked Image Viewer

Glenn — Thu, 08 May 2008 12:54:00 GMT

Welcome to the eighth of 31 applications we will post (in addition to the contest participants' submissions). Make sure you add this blog to your RSS / Atom feed and check the gallery for summaries of all the apps as they are released.

This application demonstrates linking two viewer controls together; one working as the main viewer while the other provides an overview of the entire image, outlining the currently viewable area of the main viewer.

This setup allows the end-user to quickly scroll to a specific area of the image by dragging the outline in the overview image.

To use this application, select Open from the File menu and choose a file to view. Once the image is loaded you will see a blue outline in the image overview. Grab this outline and drag it to the area of interest and the main viewer will automatically scroll to this position.

Download the installer.

Download the source.

Extending NAnt with your own types

dterrell — Thu, 08 May 2008 10:51:00 GMT

Last time I talked about how to nest existing elements in your custom NAnt tasks. Now that you've had a good look at that, and Jacob's custom task, there's only one other thing to cover in this subject: a new type.

Types end up looking a lot like a new task, but throwing this all together should be a lot of fun.

Last time, I explained how I envisioned this working; a neat little task that I would give a FileSet to, and a regular expression plus a replacement string on match. Considering this is a build process, you're going to be manipulating a lot of files with the same regex, that we have covered. But what if I want to apply more than one regex to each file that's processed; I'd like to pass a collection of regex elements to my AtalaFileRegex task along with my FileSet. For that you need the BuildElementCollection decorator on one of your field types, like this:

         /// <summary>
        /// A collection of regex/replace pairs that will be used on the file
        /// </summary>
        [BuildElementCollection("regexs", "regex", Required = true)]
        [StringValidator(AllowEmpty = false)]
        public AtalaRegexCollection Regexs
        {
            get { return _regexs; }
        }

As Jacob explained, we're requiring this field exist in our task, and that it cannot be empty. But what about those first two arguments to BuildElementCollection? Those define the outer element's name, and the inner elements name, respectively. This will make your task have the following form:

</regexs>

</fileset>

</task>

Now, all we're missing is the two types we said we're going to use in the BuildElementCollection.

First, we need our regex type so that we can work with it in our collection. For a type, you decorate the class itself, extend the Element type, and then decorate elements within the class as we've done before:

using System;
using NAnt.Core;
using NAnt.Core.Attributes;

namespace Atalasoft.NAnt.Types
{
    /// <summary>
    /// Represents an regex pattern
    /// </summary>
    [ElementName("regex")]
    [Serializable()]
    public class AtalaRegex : Element
    {

        #region Public Instance Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="AtalaRegex" />
        /// class.
        /// </summary>
        public AtalaRegex()
        {
        }

        #endregion Public Instance Constructors

I threw in the empty constructor since it's uninteresting.

Cool, now, we said we want the regex type to accept both a matching pattern and a replacement string, so let's get a couple of instance fields going on to hold those:

        #region Private Instance Fields

        private string _value;
        private string _replace;

        #endregion Private Instance Fields

And finally, our getters and setters, properly decorated:

        #region Public Instance Properties

        /// <summary>
        /// The actual regex string
        /// </summary>
        [TaskAttribute("value")]
        [StringValidator(AllowEmpty = false)]
        public string Value
        {
            get { return _value; }
            set { _value = value; }
        }

        /// <summary>
        /// The replacement string on match
        /// </summary>
        [TaskAttribute("replace")]
        [StringValidator(AllowEmpty = true)]
        public string Replace
        {
            get { return _replace; }
            set { _replace = value; }
        }
        #endregion Public Instance Properties
    }
}

Notice on each, we've named the attribute (I called the regex string 'value' because I didn't want an element like <regex regex...). Also note, the replace string can be empty.

That's all there is to making your own, simple type. We'll move on to the more "complicated" part of the task at hand.

Second, realize that we told NAnt it's a collection, so when we make our regexs type it's going to need to extend the CollectionBase abstract class. You need nothing from the NAnt core. Let's set up the class, and the default constructors:

using System;
using System.Collections;

namespace Atalasoft.NAnt.Types
{
    /// <summary>
    /// Contains a strongly typed collection of <see cref="AtalaRegex" /> objects.
    /// </summary>
    [Serializable()]
    public class AtalaRegexCollection : CollectionBase
    {

        #region Public Instance Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="AtalaRegexCollection"/> class.
        /// </summary>
        public AtalaRegexCollection()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AtalaRegexCollection"/> class
        /// with the specified <see cref="AtalaRegexCollection"/> instance.
        /// </summary>
        public AtalaRegexCollection(AtalaRegexCollection value)
        {
            AddRange(value);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AtalaRegexCollection"/> class
        /// with the specified array of <see cref="AtalaRegex"/> instances.
        /// </summary>
        public AtalaRegexCollection(AtalaRegex[] value)
        {
            AddRange(value);
        }

        #endregion Public Instance Constructors

From here, there's a lot of things to implement from the CollectionsBase class, and an enumerator. Suffice it to say, you're going to end up filling in a lot of stubs for insert, add, copyto, remove, etc. There's not much to cover here, it's a stong-typed collection.

Next time we'll put these things to work in our task.

Writing NAnt tasks with nested types

dterrell — Wed, 07 May 2008 20:04:00 GMT

If you follow the Atalasoft Blogs by whatever means, and you're reading this, it's quite possible you've also read Jacob's blog post about extending NAnt. If you haven't already, go check it out since he's covered a huge amount of ground related to what I'm going to show in this and subsequent posts. In fact, I'll assume you've either read his post, or have some general idea about extending NAnt.

First, let me give some background on why I did this task.

At Atalasoft, our builds (built by Jacob) can run in parallel, but our .NET 2.0 and 64-bit builds cannot. Before our installer is created we want the .NET 2.0 and 64-bit assemblies to have the same version numbers. In order for that to happen, we introduced a dependency on the .NET 2.0 build by the 64-bit build (the version number is a guaranteed increasing, randomly generated number that, in the case of the 64-bit build, is obtained from the built .NET 2.0 assemblies). For continuous integration, the version numbering is internal, and not as important to our engineering department. With that in mind, it should be easy to break the dependency just for a nightly build, but how? Enter ChangeSetId, LastChangeLabeller, and a special Atalasoft NAnt task called AtalaFileRegex (the "Atala" prefix is somewhat of a running joke internally, but helps future build engineers realize it's not a built-in task for NAnt, yet). The ChangeSetId and LastChangeLabeller topics will be covered in another, upcoming post.

Now, you ask, why the FileRegex task when we're dealing with version numbers? Ah, well, assembly version numbers are gotten a few different ways, and I wanted to alleviate a pain in our current build setup (preceding Jacob) where we use no less than 3 different approaches for updating version numbers for 3 different file types (AssemblyInfo.cs/.cpp, and any .rc files). Enter AtalaFileRegex!

I imagined a task that I could give a FileSet to, a regular expression to match, and a string to replace that match with. It's a sharp (no pun intended) tool that you can easily break things with if you're not careful, but incredibly powerful if you are careful!

So we set out to make our task (this is where you read Jacob's blog). And in our shiny new task, we'd like to have a FileSet. Easy, peasy! In your public instance properties, make a field that is the NAnt.Core.Types.FileSet, and add some getter/setter code, like the following:

        /// <summary>
        /// All the matching files in this set will be updated according
        /// to the given regex/replace
        /// </summary>
        [BuildElement("fileset")]
        [StringValidator(AllowEmpty = false)]
        public FileSet RegexFileSet
        {
            get { return _fileSet; }
            set { _fileSet = value; }
        }

Notice I use the BuildElement() decorator here, instead of the already familiar TaskAttribute() decorator. This means that it's a nested element. The way you'd write your NAnt task with this is

</taskname>

Sweet! That was easy...

Next time I'll write a walk through on how to make your own type, and add that to your new task.

Custom Serializing Objects for Use in a Debugger Visualizer

RickM — Wed, 07 May 2008 19:02:00 GMT

I have a new CodeProject article up which details how to make a Debugger Visualizer in the case where you need to custom serialize the object. The actual classes I build in the tutorial are only useful with our DotImage project line. However, the process of creating a Custom Serializer should be useful to any .NET developer. In our case, we automatically serialize AtalaImages to PNG format by default. It turns out that PNG encoding and decoding is slow enough that visualizing a medium sized image...(read more)

Writing Custom NAnt Tasks

jacobl — Wed, 07 May 2008 17:23:00 GMT

Working as a Build Engineer for about 9 months, I've had the opportunity to push NAnt build scripting to the limits. Our DotImage product is made up of both managed and unmanaged code, third party libraries with .NET wrappers, code that sometimes differs from .NET 1.1 to .NET 2.0 (both x86 and x64) and a slew of other complications. In addition to that and the multiple systems it takes to put it all together, there comes a time where a custom solution might be the best way to do things. In the world of NAnt scripts, this can come in many forms, but personally I prefer to stay away from batch files and calls to the command-line. In my mind, the most elegant option is to write a NAnt task.

For most things, NAnt tasks already exist and can be found at either their official website or at the NAntContrib sourceforge project, but it may surprise you that one of my first projects at Atalasoft was to create a NAnt task for integrating with Team Foundation Server.

We had been using Visual Source Safe so the vssget task served us well for a long time. When we migrated to TFS, we were essentially left hanging and had nothing to go on but settle for a few batch scripts that handled the task pretty well. Needless-to-say, five or so calls to tf.exe (the Team Foundation command-line utility) is not as easy to maintain as one task in a NAnt script.

In this post, I will walk you through creating a custom NAnt task with some more "advanced" features, such as adding nested elements and setting a return value. Then, in the near future, I will post my code for the tasks that I've written including tfsGet, tfsCheckOut, tfsCheckIn, removeSourceControlBindings, and others. You'll then be able to add them to your build systems and get all of the same TFS goodness that we do. I might even add them to NAntContrib as well.

Design your Task

Before I start writing a task, I like to have a good idea of what it will look like and how it will behave in a NAnt script. In the case of TFSGet, I decided to model it after the VSSGet task which is in NAntContrib.

This is what the VSSGet task looks like:

<vssget verbose="true" username="user" password="pass" localpath="." recursive="false" replace="true" writable="true" dbpath="\\path\to\srcsave.ini" path="$/path/to/project/location" />

and this is what my TFSGet task looks like:

<tfsget server="servername" ssl="false" port="8080" projectPath="$/path/to/project/location" localPath="." recursionType="None" getOptions="Force"> <source path="*" /> </tfsget>

Since I wrote it last year, Dave Terrell, our Build Engineer has made a few important additions such as non-default network credentials as well as the ability to return a changeset number back to the NAnt script. With these new changes, the task looks like this:

<tfsget server="servername" username="user" password="pass" ssl="false" port="8080" projectPath="$/path/to/project/location" localPath="." recursionType="None" getOptions="Force" changeset="changeset"> <source path="*" /> </tfsget>

Let's Get Started

Open Visual Studio and create a new project. NAnt tasks start their lives as Class Libraries, so that's the template that we'll choose. For this example, I'm going to create a project called TFS since it will hold all the tasks related to TFS. I might want to add more tasks in the future that aren't related to TFS so my overarching solution will be called Tasks.

After your project and solution appear in the Solution Explorer, we need to rename the Class1.cs file to TFSGet.cs. Visual Studio may ask you if would like Visual studio to rename all references to Class1 in the project to TFSGet. Say Yes, otherwise do it manually.

Before we get started writing any code, we need to reference NAnt.Core.dll. That assembly is located in the directory structure of your NAnt install right next to NAnt.exe. Once you've done that, add the appropriate using statements to the top of your TFSGet.cs file.

Five Steps to Success

To define a NAnt task, there are five things we need to do:

Define the name of the task using the TaskName class decorator.
Extend NAnt.Core.Task.
Create any attributes and label them with the TaskAttribute property decorator.
Override the ExecuteTask method.
Make sure you're output assembly ends in Tasks.dll.

The Basic Layout

Here's the skeleton for our TFSGet task:

// using ... using NAnt.Core; using NAnt.Core.Attributes; // ... namespace TFS { public class TFSGet : Task { #region Task Attributes

private string _server; [TaskAttribute("server", Required = true)] [StringValidator(AllowEmpty = false)] public string Server { get { return _server; } set { _server = value; } }

// ... other attributes ...

#endregion

#region Execute

protected override void ExecuteTask() { // The Leg Work }

#endregion } }

With this basic model, you can write almost any task you can think of. There are two other important concepts that this particular task employs and you should know about them and how to use them. One is returning values and the other is nested attributes. I'll explain return values shortly, but nested attributes are a bit more complicated and deserve a dedicated post. I will leave that to Dave to explain further. He's written about writing NAnt tasks with nested types as well as extending NAnt with your own types.

Using "Project"

Project gives you access to the currently running NAnt script. This is essentially the parent of your NAnt task. With it, you can log events, warnings, or errors. You also have access to properties within the project allowing you to return values from your task to the outer build script.

In the case of this example, it is incredibly useful for the build script to know the changeset of the code we got from TFS. In the script, we can then use that number to ... maybe set the version number of our assemblies for quick debugging if a customer has a question. If they give us that, we can instantly see the code that their running without having to think about it. Currently, our assembly version numbers at Atalasoft are:

6.0.<randomish number bigger than the last build>.<randomish number>

For future versions of our product we are working toward version numbers like:

x.0.<number representing the letter of the build>.<changeset number>

For example, if you called our office with a question about your 6.0.0001.38983 assemblies, we would instantly know that you are running 6.0a and we can get changeset 38983 from source control and read exactly what you've got.

Setting project properties is very simple. To set a property, you simply set the value of item indexed by the property you are setting. That was a mouthful... If you are trying to set the "changeset" property, this is what you would do:

Project.Properties["changeset"] = value;

That's it!

Logging is just as easy. To log you simply call:

Project.Log(Level.Info, "Your logged message goes here");

That message will now appear in the console if you're running your NAnt script via command line. It will also appear in your CruiseControl logs if you're using that to manage your Continuous Integration process.

Deploying a Custom Built NAnt Task

To deploy a custom NAnt task, you simply need to put it in the NAnt directory next to the nant.exe and NAnt.Core.dll that you will be running it from. The next time you call nant.exe, your newly built task will be loaded and available to be scripted against.

The Code

Here's the code for this task in full and here's a link to a prebuilt assembly. You will need to download and install NAnt and you may or may not have to download and install Visual Studio TeamFoundation Server SDK for access to the Microsoft.TeamFoundation namespace items.

Check back in the future for more NAnt tasks and be sure to read Dave's articles on using nested types as well as creating your own.

Scan Documents to Scribd

loufranco — Wed, 07 May 2008 13:15:00 GMT

Welcome to the 7th of 31 applications we will post (in addition to the contest participants' submissions). Make sure you add this blog to your RSS / Atom feed and check the gallery for summaries of all the apps as they are released.

Just in time for the Scribd "Most Interesting Hard Drive Contest", here's a free application that can scan documents and upload them to your Scribd account. You can choose to OCR them first, so that your scanned documents will show up in search queries (courtesy of the Google Tesseract OCR engine). Now you can try to win a MacBook Air from Scribd with the scraps of paper lying around your office.

Download the Scan To Scribd installer and run it.

Scan in a document, then Click the "Upload to Scribd..." icon and provide your API Account and Scribd login info (it will be saved for next time).

You can give your document a title and specify whether it's public or private. You can also choose to OCR the file before uploading it. When it's done, go to Scribd and view your document.

This application uses the amazing Scribd.Net, which makes it easy to interact with Scribd from .NET.

Download the application

Download the source

To build your own version from this source, you'll need to get an API Key from Scribd first. Sign in and then go to your platform account page (click on your own name in the upper right corner), your API Account information is on the right side. It will take a few minutes to become active.) In the downloaded source, you can hardcode your own API Key.

About Atalasoft's 31 Apps in 31 Days

Update on another post

dterrell — Wed, 07 May 2008 11:43:00 GMT

You may have seen my post in the 31 Apps in 31 Days blog. If you haven't already seen the 31 Apps in 31 Days blog, definitely check it out! There's already a week's worth of applications you can make using the Atalasoft family of tools in one way or another.

I got some requests to expand the functionality of my autorotater application, namely that it have some additional rotational functionality. Sometimes you'll stumble on those pictures that were taken with an orientation 90 degrees to the right or left, or even upside-down. Some viewers will read this orientation information and rotate the picture for you while viewing, but at the same time they don't update the orientation flag of the image. As a result the image may continue to be rotated by other viewers, or in this case, it'll be rotated by the AtalaAutoRotater.

To fix this, I've added two new buttons to the autorotater. This functionality was pretty easy to add with these few steps (technical stuff here, skip to MultiSelect if you don't like techie stuff).

Modify the selectedIndexChanged event handler to enable/disable the rotation buttons. This is just an added visual to let users know they must select one or more images before rotating
Add two buttons, and give them appropriate names btnRotLeft and btnRotRight.
Add a wrapper function rotate_() that will gather a collection of thumbnails into a new ICollection<Thumbnail>() before calling rotate()
Add a new enum that contains Left, Right, All
Have the btnRotLeft and btnRotRight (modify btnRotate) call the wrapper with its direction
Modify rotate() so that it accepts an ICollection<Thumbnail> and a Rotation enum. Check, before the switch, whether it's rotating all images, or a selection and update the orientation int if it's a selection Left/Right.
Let the rest of the code do the work!

MultiSelect

But wait! You don't want your users having to select individual files and hit rotate buttons each time. So we'll make it possible to select a whole set of images to rotate. To select multiple images, users can either hold down the Ctrl key while selecting individual pictures, or the Shift key to select two endpoints of a range of photos.

For this functionality, the FolderThumbnailViewer needs to be updated as well. This might be a bit confusing, because there are two spots where you need to change options to get multiselect working, both in the FolderThumbnailView properties matrix. First, you have to enable MultiSelect, then you have the change the SelectionMode to MultiSelect from Single. Once that's done, the app is ready to go!

To make this a bit easier, I've included the source in the installer this time so there's only one file to download.

Get the installer

Lou Francos

Steve Hawley — Tue, 06 May 2008 19:25:00 GMT

I was playing with the Product Box Generator and created the following bit of fun:

I love software.

Thanks, Lou, for tolerating me.

TPS Coversheet Enforcement

Steve Hawley — Tue, 06 May 2008 13:35:00 GMT

Welcome to the sixth of 31 applications we will post (in addition to the contest participants' submissions). Make sure you add this blog to your RSS / Atom feed and check the gallery for summaries of all the apps as they are released.

This app is a frivolous way to solve the general problem "how do I detect and act on the content of a scanned document"?

If you've seen the movie Office Space, you're well aware that all TPS reports are required to have a specific cover sheet. I've written an application that does two things - first, given a folder it will find all TIFF documents within the folder and flag any TIFF wherein the first page is NOT a TPS cover sheet. The second thing the application does is to insert a TPS cover sheet into files that are missing one.

The first task is simple, if you have the right pieces at your fingertips. Using the Tesseract OCR engine, I recognize the first page in each document and attempt to match text on the page via a regular expression. If there is a match, then the document has a TPS report cover sheet.

The second task uses our new TiffDocument class to add in the cover sheet. Because of this class, this task is literally a one-liner.

While this particular application is frivolous, you could imagine using the same structure to auto-sort documents that come in from a fax source or do keyword searching.

You can download an installer for the app here.

You can download the source here.

About Atalasoft's 31 Apps in 31 Days

When "new" is Too Slow

Steve Hawley — Mon, 05 May 2008 13:46:00 GMT

I was working on some prototype code that needed to be super fast. After getting basic functionality up and running, I found that the biggest chunk of time was getting lost in operator new. In this particular chunk of code, I had some simulated recursion that was making lots and lots of little objects that were being pushed and popped onto a stack. The issue was that these objects are tiny and transient. This means that all the overhead imposed by new and delete will get charged again and again and again.

There are a number of choices available to you when you do this. I'll pass on one that breaks a number of conventional OO design rules, specifically is-a/has-a. In my case, I had some objects that have two purposes in life - to hold data and to live in a stack. If you are a fan of STL, you will probably haul out stack<t> and call it good. In my case, STL's performance was heinous, so I chose to smudge the is-a/has-a line and make my little object into a stack element rather than using a stack element to hold it:

class StackPoint { public: StackPoint(unsigned int x, unsigned int y) : m_next(NULL) { m_pt.x = x; m_pt.y = y; } StackPoint (POINT pt) : m_pt(pt), m_next(NULL) { } virtual ~StackPoint () { } int X() { return m_pt.x; } int Y() { return m_pt.y; } void SetX(int x) { m_pt.x = x; } void SetY(int y) { m_pt.y = y; } StackPoint *GetNext() { return m_next; } void SetNext(StackPoint *next) { m_next = next; } private: POINT m_pt; StackPoint *m_next; };

class MyStack { public: MyStack() : m_stack(NULL) { } virtual ~MyStack(); bool IsEmpty() { return m_stack == NULL; } void Push(StackPoint *item) { item->SetNext(m_stack); m_stack = item; } StackPoint *Pop(); private: StackPoint *m_stack; };

In these snippets, I'm leaving out some of the methods, but they're simple to write. Pop() returns null if the stack is empty, or the top of the stack otherwise, resetting the stack pointer. The destructor rips the entire stack, disposing each element in turn. From these two classes, I can now create an allocator like this:

class StackPointAllocator { public: StackPointAllocator() { } virtual ~StackPointAllocator() { } StackPoint *Alloc(int x, int y); void Free(StackPoint *p); private: MyStack m_stack; };

In this case, the StackPointAllocator has a method called Alloc which will do one of two things. If m_stack.IsEmpty() is true, it will call operator new. If m_stack.IsEmpty() is false, it will pop the top item off, set x and y and return it. In the typical case, there is an item left on the stack and so "allocation" (really recycling), is only a few assignment statements. Note that m_stack is a NOT a pointer, which means that its destructor will automatically get called when the allocator goes out of scope or is deleted.

To give you a sense of the power of doing this, the original problem with allocation was costly because I was allocating tens of millions of these objects, each of which has a very short life span.Even though the individual cost was small, multiplying by 10M added up. I'd rather do 40M assignments. Once the code was refactored (easy), the time for allocation totally vanished from the performance profile.

Now, the real C++ programmer question is "Why didn't I override global operator new for StackPoint?"

Overriding global operator new means that all code that allocates these objects will go through the global allocator - that's a bigger deal. I use this code in other places that shouldn't use this allocator. I end up making the allocators I use stack objects, which means that objects in the free list disappear when they go out of scope.

Classic engineering dilemma: which is more important? performance or OO design? In this case, the API is NOT public, so the dirty little secret is hidden away, making this a perfectly acceptable choice. Performance, FTW. In addition, there were two other considerations - readability and expedience. Readability was not lost at all, and since I could knock this out inside a half hour, I won on expedience too.

When just one watermarked image simply isn't enough

Kevin Hulse — Mon, 05 May 2008 13:10:00 GMT

Finally, the Atalasoft Batch Watermarker, the cure to all your watermarking woes! With this application, you no longer need to spend hours toiling in Photoshop repeating the same action over and over again! No more--::Mute::

While this application might not be that ultimately useful, it stands to save some intern a lot of time, or even you a lot of time. As someone new here at Atalasoft, I have been astounded with what we have to offer. The Atalasoft toolkit is so mind-blazingly fast; both in running speed and developer time.

Three lines of code to allow the user to select any supported format image and display it in a Windows form: Two lines of code to perform an operation on it: One line of code to save the image in any supported format. The basic image processor is 6 lines of code.

I designed this 31 app to show off the ability to use DotImage to do many steps of photoshop style processing (that noone really wants to do by hand) automatically. Simply point the watermarker at a folder containing jpgs, configure your watermark in real time, and select Apply Watermark, and another folder is created containing all the images with your watermark applied.

Give the Atalasoft Batch Watermarker a try!
Feel free to check out my source code

~Kevin
Atalasoft Developer Support Engineer

About Atalasoft's 31 Apps in 31 Days

Make sure you add this blog to your RSS / Atom feed and check the gallery for summaries of all the apps as they are released.

Presenting at the Western Mass.NET Users Group

jacobl — Mon, 05 May 2008 12:59:00 GMT

I will be doing a presentation on build automation using CruiseControl and NAnt at the Western Mass .NET Users Group meeting on May 6th at 6pm.

The presentation will cover the basics of CruiseControl and NAnt as well as developing custom tasks to stretch this already flexible framework even further.

Batch Thumbnails

Steve Hawley — Sun, 04 May 2008 15:35:00 GMT

This application is a command line tool for generating thumbnail images. To use it, unzip the executable and run it from a command prompt. The typical usage is:

thumbnailer /maxwidth width /maxheight height folder1 folder2 folder3

Thumbnailer will open every image in every folder supplied and will create a thumbnail image is the same proportions as the original image, but will not exceed the maximum width or height.

By default, output thumbnails will be put into the same folder as the original image. If the original image is named originalname.ext, the output thumbnail will be named tnoriginalname.jpg. If tnoriginalname.jpg exists, it will not be overwritten.

thumbnailer needs at least one folder to operate on, but it can accept any number.

If you omit maxwidth or maxheight, they will be 64 by default.

The complete set of options are as follows:

/nobanner - when this option is present, thumbnailer will not print a banner message to the error output stream.
/prefix thumbnailprefix - sets the prefix to use on output files. The default value is tn. Output files will be named thumnailprefixoriginalfilename.jpg
/suffix thumbnailsuffix - sets the suffix to use on output files. The default value is the empty string. Outputfiles will be named originalfilenamethumbnailsuffix.jpg
/maxwidth width - sets the maximum width for an output thumbnail
/maxheight height - sets the maximum height for an output thumbnail
/outputfolder folder - puts all thumbnails from all original folders into the specified output folder. The default action is to put them in the same folder as the source images
/overwritethumbs - if present, this options will cause existing thumbnails to be overwritten, otherwise existing thumbnails are ignored.
/doprefixedfiles - if present, this option will cause files that start with the thumbnail prefix to be turned into thumbnails. By default, they are ignored.

Options can start with / or - to make both DOS users and UNIX users happy.

Inside the Source Code

The source code is very simple - most of the code handles command line arguments. If you look at the Main method, you will see that the app makes a single eponymous object, processes arguments, prints a banner, then makes thumbnails.

The method MakeThumbs with no arguments loops over a list of folders and delegates the task of creating thumbs to another flavor of MakeThumbs which loops over each image file in a folder, makes a thumbnail image, then writes out the file, if appropriate.

MakeThumb reads in an image, turns it into a thumbnail using a ResampleCommand object then returns the thumb.

Download executable

Download source

Product Box Generator

Glenn — Sat, 03 May 2008 15:11:00 GMT

Welcome to the third of 31 applications we will post (in addition to the contest participants' submissions). Make sure you add this blog to your RSS / Atom feed and check the gallery for summaries of all the apps as they are released.

This application will generate a software package box image with up to three images for the front, side and top of the box. Each image can be stretched to fit its area or centered with a background color.

Usage:

Choose the images to use for the box areas by either typing the location of the file or clicking the button to the right of the textbox for a file dialog. If an image is not supplied, that area will be filled with the background color.
Place a checkmark in the Stretch checkbox to have the image stretched to fit the area. When unchecked the image will be centered within the area.
Click the button to the right of “Background Color:” to select the color used when an image does not fill the area.
Click the Generate button to create the image.

Once the image has been generated, it can be saved using the File > Save menu item.

Download the installer.

Download the source.

About Atalasoft's 31 Apps in 31 Days

Using PNG Predictors to Enhance GZIP/PKZIP/FLATE Compression

RickM — Fri, 02 May 2008 20:25:00 GMT

I’ve been doing a lot of work in the PDF space lately. While implementing Binary Cross Reference Streams I was surprised to see that they could be encoded with PNG Predictors. This was surprising to me because binary cross reference streams aren’t images, they are byte tables: While the values vary, they are often within the same ranges. The first byte can only contain the numbers 0, 1 and 2 and are often the same, the middle two bytes are often the same and the last byte is generally increasing...(read more)