VisualHint blog

Smart PropertyGrid and Smart FieldPackEditor for .Net 8

.Net 8 assemblies have just been added to the nuget packages.

SPG for .Net 6+ is now version 4.2
SFPE for .Net 6+ is now version 2.2.1

On this occasion, I had to update SPG to fix a .Net 8 regression in the KeysConverter class. I've raised this issue with the Microsoft development team and they should fix it for .Net 8 and .Net 9 preview.

Smart PropertyGrid and Smart FieldPackEditor for .Net 7

Since .Net 7 has been released last week, I have added .Net 7 assemblies to the nuget packages.

SPG for .Net 6+ is now version 4.1
SFPE for .Net 6+ is now version 2.1

Note that both products are newly labelled "for .Net 6+" to include current and upcoming .Net versions starting from 6.

Fluent API updated

So far, you were able to configure a category with a specific call, and configure child properties this way:

.ForCategory("Credentials", category => category.Comment = "my comment")
.ForProperty(x => x.Username, config => config
    .Category("Credentials", 1)
    .Id(1000)
)

As you can see the calls are at the same level. The property definition had to mention the parent category in order for, let's say, set a sorting index. This kind of mimics the way attributes work. You can attach a CategoryAttribute to a property to set a category sorting index. Obviously this is not very intuitive when using a fluent API. Therefore, I added a new way to define categories and properties and this now displays as a 2-levels hierarchical tree:

.ForCategory("Credentials", config => config
    .Sorted(1)
    .Comment("my comment")

    .ForProperty(x => x.Username, config => config
        .Id(1000)
    )

Note that these methods are also available inside ForCategory to configure a category:

Sorted to set a sorting index.
Comment to add a description.
ImageIndex to add an icon on the left of the category label.
ValueText to set a secondary text on the right side of the category label.

That way, this is clear that you define some settings for a category and then for its child properties.
This is in version 4.0.2 and ready for you to enjoy.

VisualHint runs now on Asp.Net Core 6

The VisualHint web server had been running .Net Framework and Asp.Net Mvc 5 for a long time and I had never developed with Asp.Net Core before. I thought it would make an interesting project to migrate it to Core and the result is now live in front of your eyes. It took me weeks to build it because so many things have changed. Here is a non-exhaustive list of all the impacted areas:

Dependency injection (many of my internals migrated to injected services)
MVC pipeline
Routing
Bundling and minifying
Session storage
Authentication and authorization
Background jobs (commands and maintenance tasks) - Now using Quartz
RavenDb
AutoMapper
Logging (was using RavenDb store, now in memory waiting for a better solution)
Emailing
Async everywhere
and a ton of small other things in my code

It was huge, really, but I'm pretty happy with the result. Things to note:

The mailing list is broken. I was using a homemade library and it's an enormous job to port it. Don't know when I can fix that.
Since the authentication system had to change, your password is not usable anymore. You will have to reset it by going to the lost password route.

The server is still hosted by Azure. Ultimately, I would like to move it to a cheaper linux box.

With so many changes, bugs may happen. Please contact me if you encounter any issues. You can also do so if you are in such a migration and need some help. Who knows if I can give some advice based on this recent experience.

Smart FieldPackEditor Final for .Net 6, version 2.0.0, is released

After releasing Smart PropertyGrid for .Net 6, customers pressed me with questions about whether Smart FieldPackEditor would also be available for the latest version of .Net. The porting was already done but I hadn't updated everything about the build, licensing and publishing as a NuGet package. It is now done. You will find:

A trial package on nuget.org. The adapter for SPG is also on nuget.org.
The licensed product on a private NuGet server.
Usual samples on Github.

I took the opportunity to also release SFPE for .Net Framework as a NuGet package, and your purchased copy is on a private NuGet server too.

AS a reminder, SFPE for .Net 6 is considered a new product. If you already own licenses for .Net Framework, there is no upgrade path and you need to purchase new licenses.

Smart PropertyGrid Final for .Net 6, version 4.0.1, is released

A short time after the final release of SPG for .Net 6, here is an updated version with many new methods added to the Fluent API (+ a crash fix). With it comes a completely new sample that you can find on Github, showing all possibilities of the API. Frankly, it's quite cool, and I'm sure you will give me your ideas to enhance it even more.

For the pleasure:

// FontColor property is not created because it is later added manually as a child of a Font property
.ForProperty(x => x.FontColor, config => config.FilterOut(PropertyPreFilterOutEventArgs.FilterModes.FilterOut))

.ForProperty(x => x.MyFont, config => config
    .Sorted(propertySortedIndex++)
    .Category(ReflectionCategory, 5)
    .DisplayName("Font")
    .Comment("This property content is discovered by reflection but I customized it to hide certain subproperties, add a Color property, set the booleans as checkboxes with various texts and assigned up/down buttons to Size.")
    .ChildLook<PropertyCheckboxLook>("Italic")
    .ChildLook<PropertyCheckboxLook>("Strikeout")
    .ChildLook<PropertyCheckboxLook>("Underline")
    .ChildLook<PropertyCheckboxLook>("Bold")
    .ChildFeel("Strikeout", FeelCheckbox)
    .ChildFeel("Italic", FeelCheckbox)
    .ChildFeel("Underline", FeelCheckbox)
    .ChildFeel("Bold", FeelCheckbox)
    .ChildFeel("Size", FeelEditUpDown)
    .ChildDisplayedValues("Bold", new string[] { "", "" })
    .ChildDisplayedValues("Italic", new string[] { "Yes", "No" })
    .HideChildProperties("GdiCharSet", "GdiVerticalFont", "Unit")
    .PropertyCreated((args, grid) =>
    {
        args.PropertyEnum.Property.Value.Validator = new PropertyValidatorFontSize(5.0f, 15.0f);

        // In case LazyLoading==true, the children have not been created yet, so expand the property to be sure...
        grid.ExpandProperty(args.PropertyEnum, true);

        var childEnum = args.PropertyEnum.Children;
        if (childEnum.Count > 0)
        {
            childEnum.MoveFirst();
            childEnum.Property.Comment = "Uses a UITypeEditor. By the way, you can set comments to auto-discovered subproperties...";
            childEnum.MoveNext();
            childEnum.Property.Comment = "A custom feel has been applied to this property. It is done by setting an attribute to its parent. Also a validator constrains the value between 5 and 15.";
            childEnum.Property.Value.Validator = new PropertyValidatorMinMax((Single)5.0, (Single)15.0);
            childEnum.MoveNext();

            var propEnum = grid.InsertProperty(childEnum, 150, "Color", grid.SelectedObject, "FontColor", "");
            propEnum.Property.Feel = grid.GetRegisteredFeel(FeelList);
            propEnum.Property.Look = new PropertyAlphaColorLook();
            propEnum.Property.Comment = "This color has been added to the children of the font. It uses an alpha color editor.";

            propEnum.MoveNext();
            propEnum.Property.Comment = "The text of a checkbox can be removed.";
            propEnum.MoveNext();
            propEnum.Property.Comment = "The text of a checkbox can be customized.";

            grid.ExpandProperty(args.PropertyEnum, false);
        }
    })
)

Here you can see some nice built-in methods like Sorted or ChildLook. And when you need complex customizations, you always have an handy event to go deep inside the SPG api.

Smart PropertyGrid Final for .Net 6, version 4.0, is released + new Fluent API

Today is a great day for VisualHint with 2 important news.

I'm pleased to announce the officiel release of Smart PropertyGrid for .Net 6 today. It is available as a NuGet package on nuget.org for the trial version and on your private NuGet feed for the purchased version.

I have also added a completely new feature allowing you to fill the grid traditionally with SelectedObject and to customize each property with a Fluent API. It means that you can have on one side your business objects without any PropertyGrid attributes, the PropertyGrid itself, and some custom separate classes (profiles) to customize how your business objects appear in the grid. Right now the API is minimal and an in-progress work based on your requests. You will find the online documentation here.

Next step: I'm cloning the PropertyGridShowRoom sample to use SelectedObject and this fluent API. This will drive new additions to the API.

Don't hesitate to let me know what you think!

Initial expanded state of properties and PropertyGrid state saving/restoring

Once more, the idea of this article comes from a question I found on StackOverflow.

I would like to automatically expand some nodes in a PropertyGrid loaded with an instance of my SettingsStructure class by using attributes on the properties of that class. Also, I am attempting to have the instance 'remember' whether each property was expanded or not if the user loads that instance again on the PropertyGrid.

I was curious to see how easy/difficult it is to get this done in Smart PropertyGrid when using SelectedObject.

Here is a class to populate the grid:

public class TargetClass
{
    [PropertyExpanded]
    public Size Size { get; set; } = new Size(10, 20);
}

Initial expanded state for a property

This was really easy to set up an attribute to do that thanks to the new addition discussed in the previous blog post:

public class PropertyExpandedAttribute : PropertyCreatedHandlerAttribute
{
    public override void OnPropertyCreated(PropertyEnumerator propEnum)
    {
        propEnum.Property.ParentGrid.ExpandProperty(propEnum, true);
    }
}

And voilà, Size is expanded when SelectedObject is given an instance of TargetClass.

Save and restore the PropertyGrid state

Answering this question was instantaneous. Smart PropertyGrid already offers this feature. Here is an example taken from the online documentation:

var states = myGrid.SavePropertiesStates(PropertyStateFlags.None);
myGrid.SelectedObject = newTargetInstance;

// Then later
myGrid.BeginUpdate();
myGrid.SelectedObject = originalTargetInstance;
myGrid.RestorePropertiesStates(states);
myGrid.EndUpdate();

Note that SavePropertiesStates saves some states by default. The expanded state is one of them. First displayed and selected properties are some others. Passing PropertyStateFlags.None to this method does not mean that it must not save states at all. It means that it should not save more states (like colors and fonts) than the default ones.

The sample for this article has been added on github.

Smart PropertyGrid makes it super easy to select an item in a collection property

On internet, I have often seen the following question:

I have a collection (a list or a dictionary) and I would like to show a property in the PropertyGrid that allows me to select an item from the collection.

This kind of question can be seen in these 2 examples:

I then wondered if it was possible to provide a solution without having to modify SPG. This was quickly found by using the PropertyCreated event and calling PropertyValue.ResetDisplayedValues with the correct values to place in the list.
As the question is recurrent on the net, I decided to integrate my solution inside SPG. In the client application, you just have to apply the CollectionPropertySelector attribute to a property that will act as a selected index in a list or as a selected key in a dictionary. Only one parameter is required: the name of the collection in the class. Here is an example in a TestClass:

public TestClass()
{
    PlanetList = new List<Planet> {
        new Planet("Mercury"),
        new Planet("Venus"),
        new Planet("Earth"),
        new Planet("Mars"),
        new Planet("Jupiter"),
        new Planet("Saturn")};
    MyPlanet1 = 2;

    PlanetDictionary = new Dictionary<string, Planet> {
        { "Mercury", new Planet(1) },
        { "Venus", new Planet(2) },
        { "Earth", new Planet(3) },
        { "Mars", new Planet(4) },
        { "Jupiter", new Planet(5) },
        { "Saturn", new Planet(6) },
    };
    MyPlanet2 = "Earth";
}

[Browsable(false)]
public List<Planet> PlanetList { get; set; }

[DisplayName("Home planet")]
[CollectionPropertySelector(nameof(PlanetList))]
public int MyPlanet1 { get; set; }

[Browsable(false)]
public Dictionary<string, Planet> PlanetDictionary { get; set; }

[DisplayName("Secondary planet")]
[CollectionPropertySelector(nameof(PlanetDictionary))]
public string MyPlanet2 { get; set; }

As you can see, we apply Browsable(false) to the collection to not include it in the grid, then we apply the CollectionPropertySelector attribute to a property of type int for the list and to a property of type string for the dictionary (because the key is of type int). For this to work, a little extra tooling is required. The class that is in the list (Planet) must have a ToString() method that returns a representation of the instance. It is also possible to use a TypeConverter for the same purpose. In the dictionary case, this is not necessary because the Planet class is used as the Value and not as the Key.

In order for the CollectionPropertySelector attribute to act when the attached property is created, I had to add a new Hook to SPG and create a parent class to this attribute that will react on the PropertyCreated event. Just before the event is triggered, I look for any attributes of this type and call their OnPropertyCreated method. You can use the PropertyCreatedHandlerAttribute base class with your own attributes to react to this event. Later on, I will add the same mechanism for other types of events, allowing you to build a set of attributes that can act at the right time.

You can right now find this feature in SPG for .Net 6 version 4.0.0-rc.5 (available on nuget.org).

Do you have some small challenges like this to submit to me? Let me know if you have some needs and you are not sure if SPG can help you right away or thanks to a new feature I could add for you.

Smart PropertyGrid is available as NuGet packages

Starting now, future customers can download the trial versions from nuget.org directly inside Visual Studio.

SPG for .Net 2 to 4 has ID VisualHint.SmartPropertyGrid.Trial
SPG for .Net 6 has ID VisualHint.SmartPropertyGrid-net6.Trial

Customers who have purchased SPG will find a key in their customer area to access a private NuGet server where they can download the final version of the product. The documentation has been updated to reflect this new reality.

Smart PropertyGrid for .Net 6 RC is available

Many of my customers are currently migrating their applications to .Net 6 and it was important to port SPG to this new .Net version. So, I am happy to announce today the availability of SPG for WinForms / .Net 6, for now in a Release Candidate 2 version. Here is what you need to know if you want to use it:

SPG is now available through a private NuGet feed. Its URL is viewable in your customer dashboard. The trial will soon be available on nuget.org too. For those who buy the product with the source code, an installation package is still available in the customer portal.
The API remains the same so you should have no problems with your existing code.
Licensing has changed because the company that developed the 3rd-party tools I was using is no longer around (web site is alive but no answer from vendor). So they don't have a new version to manage licensing and obfuscation under .Net 6 and Visual Studio 2022. You will find in the documentation the small changes to make to your projects.
The documentation is no longer delivered in PDF format. You will find it online. I now write it in Markdown format and statically generate the web pages as soon as I make a change on the pages that are stored on Github. So, changes will be faster and search engines will be able to index it, which is also a good thing to make VisualHint known.
Like the documentation, the samples are now off-site, on Github.
The migration work was a long task and I decided, as a solo developer and for survival reasons, to treat SPG for .Net 6 as a new product. So you will have to buy new licenses (the purchase page now asks you which version you want to buy). Since SPG for .Net Framework is a very mature product, I'm going to leave it as is and only make bug fixes. The good news is that the version for .Net 6 will continue to evolve. Therefore I want to listen to all your feature requests. In the near future I will propose a new one.

For your new projects under Winforms / .Net 6, you can be sure that the PropertyGrid you have always loved will continue to follow you. Don't hesitate to write me for any question.

PS: btw, I looked at the copyright message at the bottom of the site and noticed that I completely missed the 20 years anniversary of VisualHint last year. And I'm still here in business hoping that it will last a long time!

The blog is back to life

It's been almost 10 years since a post was made on this blog. To properly announce the upcoming news, I'm reopening it today. Although this website is now showing its age, I have modernized the display of the articles a bit. As my messages are created in Markdown format, I updated the libraries that process them and use MarkDig on the server side and Marked on the client side in my admin interface. The code blocks are colored with the Prism.js library. As for the RSS feed, it is still valid and you can follow the news of VisualHint in your favorite reader.

See you soon for exciting news about your favorite PropertyGrid.

New critical updates

The products you love from VisualHint continue to be refined. Starting with version 3.3.0, SPG is compatible with .Net 4.5. Prior to this "fix" SPG would crash because of the new way the IComparer interface works. SFPE has also been touched. While very stable, a recent feedback showed that it could crash when opening the month calendar if the min and max range allowed for the DateTimePicker did not contain the Today date.

It is strongly recommended to download and use these versions containing major fixes.

Important updates

This has been a long time since I last posted here. I'm sorry, I had no time to blog anymore. But last week, there was an important update to both SPG.Net and SFPE.Net so I feel I have to mention it here. My products use 3rd party licensing engine and obfuscation tools from the same company and there was two issues with them:

It was not possible to use my .Net 2 assembly on a machine where only .Net 4 is installed.
There was a crash in the VS2010 SP1 designer when opening a form containing my components.

They have now fixed these problems and I have uploaded new builds with these fixes.

Fix to VisualTips from Skybound

Smart PropertyGrid.Net does not use the VisualTips product directly, but the demo sample does. Lately, it was reported an issue (random crashes) with VisualTips if the client application targets .Net 4.0. The solution has now been found and Skybound has published a fix. You will find it here. I remind you that this is an excellent product and it's free.

And since we are talking about tooltips, I would like to outline that the latest SPG build contains refactored code for default tooltips. They now position and size perfectly in various conditions and will also now display well under Windows 7 themes.

Discounts, crisis, euro and vacations

Update: the discount is now closed.

Starting today, a 30% discount will be applied to all products and renewals (except full site and worldwide licenses). The reason is twofold:

The crisis is difficult for everyone and now especially for eurozone customers who suffer from a depreciation of their currency. Lowering my prices is a kind of participation to the recovery effort. This is a medium term decision and I have no firm expiration date.

For the shorter term, I will be in vacations from June 23 to July 7 (almost no kind of support can be provided) and from July 12 to July 20 (minimal support can be provided). So I thought this was also a reason for lowering the prices during the summer. But anyway if you place a purchase during this period, your subscription to support and updates will be extended with one additional month.

These discounts won't last forever so grab them while you can, even if your subscription is still active.

Have a good summer!

VisualHint changes its hosting provider ... and more

Starting on this Friday, Jan 29, I have triggered the DNS changes that will make visualhint.com point to its new home.

Why this move?

So far visualhint.com was a site written in php and hosted at a linux host. I was using the ExpressionEngine CMS to handle the html pages, the dynamic parts like the blog and announcements, the protected downloads and the sales through paypal. I had also a helpdesk system. This was rather flexible but it has 2 drawbacks for me: it is written in php (which is not something I master) and it is too generic. I need more flexibility to handle my customers, licenses and downloads. Being a .net guy, and also because I fell in love with asp.net MVC, I decided to rewrite my web site completely for my exact needs and I'm proud, excited (and a bit frightened) to unveil it now with a first version. It is not fully functional but its core is stable enough to make the jump.

What does it mean for you?

So far, as a customer, you had just the strict minimum: a link to download your product and your serial number. Starting with the new site you will be able to:

See your orders
See your subscriptions, expiration dates and status
See your downloads and serial numbers
Receive automatic reminders (in time... can you imagine this was manual so far?)
Purchase in CAD$ if you are canadian (it had to be a manual process outside the site so far)

I will ask you to login next week to the VisualHint web site and check your profile, subscriptions and access to downloads/serials. Please let me know if you see something wrong which does not correspond to your actual purchases. Also bear with me if you see some bugs, like receiving a reminder email several times. Here again, please inform me. At last, because all the backend is under my control, you can send feature requests about the web site. Thanks in advance.

About prices, something new?

Yes, the policy about renewals changes in your favor. So far, after your subscription to support and updates expires, you had a one month grace period to renew at a discounted price. After this period, the full price had to be paid again to renew for a year. Starting now, the grace period remains, but a simple late fee will be added (30% for the first year not renewed, 60% the second year and so on). Here is an example: for SPG.Net with sources, after the grace period, you had to pay 308 US$. Now, if you want to renew 3 months after the expiration, you will have to pay 114 US$ (the normal renewal price) + 30%, so 148 US$ instead of 308. 14 months later, it would be 114 US$ + 60%, so 182 US$. Nicer, no?

What are the next steps?

Some things will cease working: the forums (the current ones were underused anyway), the helpdesk and the MFC product pages. So at first, on the support page, you will just see an email address. Use it to contact me. I postpone the development of the forums and helpdesk because I want first to focus on my admin panel which is a central part of my new site and it must work flawlessly. I will add some new features to it bit by bit (like a dashboard, stats, and so on) which are many things invisible to you. Then I will get back to the helpdesk.

If you have any question about these changes, feel free to contact me. Also thank you in advance to put up with the small inconveniences attached to this change which is something important for the future of VisualHint.

A single checkbox for any property…

... or at least for properties that care publishing two standard values.

In the real life, you won’t always have a boolean to represent 2-states variables. Sometimes, you may have an arbitrary type, for example a simple class with two static members (something like Breaker.Opened / Breaker.Closed) or the couple null / anything. Welcome the retouched checkbox inplace control to show this property as a single checkbox. The rule is this: if your property is not a boolean, not an enumeration and not a collection, then the PropertyGrid will check if there is only two standard values (published by a TypeConverter or manually assigned by you). If this is the case, the single checkbox will be used to let the user switch between these values.

In case you are not sure how to do it with your type, there is an example in the updated sample.

The calendar is now kryptonized

A few hours after announcing the addition of a totally new MonthCalendar to the DateTimePicker supplied in Smart FieldPackEditor, here is an addon class that will paint the calendar with the Krypton palettes.

The effect with the various built-in palettes is very professional and I must congratulate Phil of ComponentFactory for the excellent job he does with the Krypton Toolkit. His product is not only a suite of very polished controls, it is also a library that 3rd party developers can use to paint their own controls. And this is a joy to use.

The supplied drawing manager for krypton painting is an example with my own tastes. You are free to modify it or derive your own class from it. If you hit some limitations related to the drawing, your feature requests are welcome (this is true for the features of the calendar too, of course).

The free MonthCalendar, as well as the Krypton drawing manager and a sample are all zipped in this archive.

A new MonthCalendar for the DateTimePicker and the PropertyGrid

There was a miss in the DateTimePicker. The editor was able to take any CultureInfo to localize the displayed strings but the popup calendar was not, simply because SFPE was still using the Microsoft MonthCalendar which accepts only the culture of the thread. It had to be fixed so I decided to write my own calendar.

This choice was also motivated by a second category of customers who use the free Krypton Toolkit API. This framework has no DateTime components (yet). For them I had just to ensure that my calendar is skinnable. But more on this in another post.

Not to make a big change, my calendar by default looks like the MS one (+ a mouse hover effect) and has the following features:

It is completely free (see at the bottom). Why? Simply because this is not my business and the community needs a good one that is also supported in a commercial package
It can be used standalone or inside the SFPE DateTimePicker
It has a CultureInfo property
It is not limited by the fateful 1753 year but by what the DateTime type can accept
It can display an optional and localizable "Today" button
It is nullable, so it can display an optional and localizable "Clear" button too
There is a true continuous acceleration when keeping the month and year buttons pressed
An overridable drawing manager allows you to customize its look

There are some limitations for this first release, simply because I needed a simple calendar for the DateTimePicker:

It displays only one month (no rows and columns of months)
It doesn't handle range selections
There is no bolded dates

That said, you have nothing to loose trying it. It's free and I think this is not just another calendar component. Personaly I tried the various ones proposed by some famous component vendors and I was not so impressed. They put the accent on the nice themes, but each time I was able to find a visual glitch or an annoying limitation.

Even if you are not a VisualHint customer, you can send me feature requests and I will enhance this calendar bit by bit (here in the comments or at UserVoice). Let me know if you like it too...

Get the month calendar here (the supplied sample references the free Krypton toolkit, so if you don't want that, simply remove the reference and the corresponding code in the form class).

An interactive calendar on your windows desktop

In 2002, when VisualHint was not born yet, I was proposing some components written in C++/MFC under the name aircom.org. The MFC PropertyGrid appeared there, as well as a DateTimePicker and color components.

Today I retrieved a nice little program, called DeskDate that I was selling for a modest 9.95 US$, and reinstalled it on my machine. Take it! It's now free (I'm not responsible if it destroys your computer, bla bla bla). DeskDate displays a permanent calendar on your desktop (you choose the number of rows and columns, and the color), behind all windows (you can bring it on the foreground with a hotkey). Right-click to access the preferences. Here is a screenshot:

Now, does it give you a clue about my new task for SFPE?

A suffix for the day of the month in the DateTimePicker

The TimeSpanEditor was able to do it but not the DateTimePicker due to the way DateTime.Parse works. I have changed that and the DateTimePicker is now able to show a different suffix depending on the day of the month. Here is an animated screenshot:

To work, you need to handle the ValueChanged event, like this:

private void dateTimePicker1_ValueChanged(object sender, EventArgs e)
{
    FieldPack fieldPack = (sender as FieldPack);
    Field field = fieldPack.GetField(3);
    if (field != fieldPack.EmptyField)
        SetDayLabel(fieldPack.OwnerEditor as DateTimePicker, field);
}
    
private void SetDayLabel(DateTimePicker dtp, Field field)
{
    if (dtp.Value != null)
    {
        DateTime value = (DateTime)dtp.Value;
        string suffix = "th, ";
        if (value.Day == 1)
            suffix = "st, ";
        else if (value.Day == 2)
            suffix = "nd, ";
        else if (value.Day == 3)
            suffix = "rd, ";

        if (!field.Value.Equals(suffix))
        {
            field.Value = suffix;
            field.OwnerFieldPack.OwnerEditor.RecalcLayout();
        }
    }
}

Depending on your language, you can of course change the prefix. Note that there is no particular requirement for the format string.

DateTimePicker and TimeSpanEditor now support frames per second

These 2 editors in SFPE.Net can now display a new field for frames per second. The maximum number of frames per second can be chosen in the format string. Here is a screenshot to show you an example:

As you can see, it takes the "v" character followed by the max frames count. Even a floating number can be used, like 29.97 for NTSC.

Note that this comes from a feature request received on July 16. I found it so useful (being a video editing fan myself) that I decided to work on it. The SFPE framework is so nice to use that I published the final result on July 23. Knowing that I had to work on other stuff as well, this surprised my customer who then sent one of the testimonials you can see on this page.

Screencast of the new TimeSpan editor for .Net

As promised last week, here is a screencast showcasing the features of the new TimeSpan editor, a new creation based on the Smart FieldPackEditor.Net:

Update: SFPE 1.2 has been released.

It is not demonstrated in this video, but I remind you that this editor can be used in the DataGridView and in Smart PropertyGrid.Net too, and with the exact same features.

If you have any question about this editor, just drop me a note here, in the forums or through the helpdesk. You will be able to play with it very soon when SFPE version 1.2 is out.

A TimeSpan editor for .Net

It seems there is no TimeSpan editor for .Net. Can you believe it? So when a customer asked me if it was possible to make one with Smart FieldPackEditor.Net, I realized I could fill a gap with a full featured duration editor, based on the flexibility of SFPE. And this is what is coming in version 1.2.

Update: a screencast has been published.

First here is a nice screenshot taken from the updated supplied sample:

You can see the editor in action and a subset of its properties in a PropertyGrid. And here are its features:

It can be used standalone, in Smart PropertyGrid or in the DataGridView. In the last case, the column of the grid can have the timespan type, long type for ticks and double type for seconds).
Flexible format string:
  • D for days without leading zeros
  • d for days with leading zeros
  • H for hours without leading zeros
  • h for hours with leading zeros
  • M for minutes without leading zeros
  • m for minutes with leading zeros
  • S for seconds without leading zeros
  • s for seconds with leading zeros
  • F (up to 7 times) for ticks as fraction without trailing zeros
  • f (up to 7 times) for ticks as fraction with trailing zeros
  • T (up to 7 times) for standalone ticks without trailing zeros
  • t (up to 7 times) for standalone ticks with trailing zeros
  • ":" for the time separtor
  • Static fields can be added, something like d 'days' H 'hours'
Min and Max values can be set.
The most significant field has no max value (except as specified by the global max value set), so you can have a value of 24 hours and more if needed.
Updown button can be displayed.
Nullable (with delete key or checkbox).
Auto-incrementation can be switched on (for ex, seconds passing from 59 to 0 will increment minutes, and so on).
A new FieldAdded event allows you to modify a field on the fly, for example to change the “day” static string to the plural “days” depending on the current value.

This new editor is a free addition to Smart FieldPackEditor.Net and is planned for release in a few days. A screencast will also be published next week.

The PropertyGrid gets Office 2007 and other themes

If you skin your application with famous themes like Office 2007 (blue, black, silver), Office 2003 or Vista, you will be happy to know that SPG.Net now offers these themes too. Here is a (resized) screenshot:

This is feasible thanks to the Krypton Toolkit API (which is a free framework available here). Instead of reinventing the wheel, I contacted Phil Wright to learn more about his toolkit and I learnt that his assembly could be used only to skin custom controls. So I have just created a custom SPG drawing manager: KryptonDrawingManager.cs. It uses all the known themes of the toolkit and you can even design your own palettes.

Screencast: How to visually synchronize two PropertyGrids?

A visitor who wanted to evaluate SPG asked me this question the other day: "I want to build a view to compare two objects visually. I want to display two property grids, one for each object. But these grids must be visually sync'ed. If user expands or collapses one property or category, other grid must do the same. If user scrolls, other must scroll too. It is possible with your component?". The answer is yes with SPG 3.0.1 and I have made a screencast to show you the result:

The synchronizer class can be downloaded here (please, let me know if you find any issue with this class, I will be happy to fix it).

PropertyGrid and property value icons screencast

As promised, here is a screencast demonstrating the various ways to attach and show an icon with a property value.

A screencast for the new features of Smart FieldPackEditor.Net 1.1

Now that SFPE 1.1 has been released, better than a thousand words, here is a short screencast to showcase its new features:

Also here is the changelog:

Version 1.1:

New features:

A convenient latitude/longitude editor has been added to wrap LatLongFieldPacks. What makes it exceptional is that it accepts values as float, double, decimal and corresponding nullable types and it can even be given your own latitude/longitude type as long as it is IConvertible to decimal or an attached TypeConverter can make the conversion.
The latitude/longitude editor has a new inplace control for Smart PropertyGrid.
The latitude/longitude editor can display its value as deg.fraction, deg min.fraction or deg min sec.fraction, with the fraction being optional.
The IpAddress editor has a new inplace control for Smart PropertyGrid. It can be attached to a string or uint property type.
Field.Readonly is now handled (behaviour and ForeColor). A ReadOnly field can still be selected. If you don't want so, just set Field.Selectable to false.
FieldPackEditor.ReadonlyForeColor has been added.
DateTimeCustomFormatConverter has been set to the DateTimePicker.CustomFormat property so that it lists all standard format strings.
There is now a simple way to set any field pack to accept the delete key or not, to nullify its content. Call the AcceptsDeleteKey property on the supplied editors or more specifically on individual field packs. The SpgSfpeAdapter also provides an attribute (FieldPackAcceptsDeleteKeyAttribute).
The visibility of the checkbox, updown and dropdown buttons can now be set through the look class in Smart PropertyGrid.
A month name field can now be edited with a numeric value (typing 2 will give february).
Jumping to the next field can now be done with the blank key or the first letter/sign of the adjacent static field.

Bug fixes:

When an editor was inside Smart PropertyGrid, its value was not commited if the user was in the middle of typing in a field.
The up/down buttons were not effective when the user was in the middle of typing in a field.
Better detection of a separator in the datetime format string. There was a problem when the user was typing a separator char prefixed by another static field.
In an editor showing the time in 12h format with an AP/PM designator, changing the hour field could incorrectly change the AM/PM designator.
Then management of the temporary buffer used while typing in a field has been enhanced.

Version 1.0:

Initial public version.

Screencast: lazy loading and default values in SPG 3.0

Here is a new screencast showcasing these two new features. Now, SPG has nothing to envy to the Microsoft PropertyGrid anymore.

Introducing Smart PropertyGrid.Net 3.0 beta

I am proud to unveil today the first beta release of Smart PropertyGrid.Net 3.0. This release is impressive by the number of improvements and changes and I will give you here the main details:

There was a real demand for it so I implemented it, making SPG the only PropertyGrid supporting this feature! As already advertised in this blog before, SPG now supports right to left languages. And not in a minimal way: each component of the grid, from the main display to each inplace control, is properly mirrored. Here is a screenshot with hebrew strings displayed:
It is good to be lazy sometimes so I decided to add some lazyness to SPG. So far, simply to keep it simple, the grid was recursively loading all properties of a target instance. It has been reported that it could be costly for large contents or even worse it could lead to a crash if there was a cyclic property path. The Microsoft PropertyGrid was able to handle these situations so there was no reason to let SPG behind. That's why I added a LazyLoading mode where child properties will be loaded only when a parent is expanded.
Icons in front of property values are now consistently managed, which lets you add any descriptive or status information with a value. You have many options to choose your image: it can come from a global image list, a property specific image list (usually when the property publishes standard values) or directly from an image reference.
The next feature comes from a single customer request but I found it so smart that I was sure everyone would love it too. This is incremental search (aka auto-complete) which enables you to quickly set a new value to a property when it publishes a set of standard values. The original idea here is that you get this feature in textboxes, in dropdown lists and even in existing UITypeEditors (like the ColorEditor) when listboxes are detected. This is a terrific usability feature for your customers!
I never was interested by this feature but many of you were asking for it and now that it is implemented I am not unhappy to see it in action. SPG, like the Microsoft PropertyGrid before, now displays non default values with a bold font. A value is "non default" when it's different from the one that is registered with a DefaultValueAttribute or when a ShouldSerialize method exists and returns true.
You found that the alpha color picker was a nice addition to SPG but you were concerned by its "private" nature. Well, you can now derive from it and override many virtual methods. Choosing to show the alpha component or not is also a built-in feature.

All these major features are showcased in the modified supplied sample. To see the full list of enhancements and fixes, simply consult the changelog.

Coming back on the scene

I know, VisualHint’s blog has been quiet for some time now, simply because internal activity has increased and the next version of SPG and SFPE are in the starting blocks. In the next days/weeks, you will see again that a lot is actually happening under the hood. Here are the next events at VisualHint:

SPG 3.0, which is already available as a preview for customers, will be published as a public beta as soon as I have updated the documentation. Here is a (resized) screenshot of the revamped supplied sample:
SFPE 1.1, which is already in beta, will be officially released.
I will often post here to explain what's new in both products. Expect some screencasts inside.
At one point, a FAQ/tips section will be opened.

Another SPG tour de force

Did you know that the Microsoft PropertyGrid is not able to let the user set a common value for collections coming from multiple target instances? Take a list or an array, this is the same story. The CollectionEditor will popup, you will alter the displayed collection and when you hit OK, nothing happens. Well, up to last week, this was the same in SPG. But with the new build, you can now edit collections when you target multiple instances with SelectedObjects. Here is a screencast to see it live:

Smart PropertyGrid.Net 2.5 RC1 is available

When I decided to fix the behavior of the grid regarding multiple target instances, I though it would be difficult and that after a lot of efforts it would produce a release perceived as minor (something that should be version 2.2.6) because this feature should have worked from the beginning or at least from version 2.0. So I gathered my courage and began investigating. I still learned a lot during the process and I realized that I could do better than what the Microsoft PropertyGrid does when it targets several instances.

The Microsoft grid is lost as soon as you target two instances that have common properties but whose values differ. From my point of view, this is not logical so I did my best to fix this behavior and I succeeded (there are some screencasts about this subject). The result is a release that you can consider major, and therefore labelled 2.5. Moreover I took the chance to add some very demanded features. Here are the more important points of the changelog:

SelectedObjects has been reworked and SPG now behaves correctly regarding multiple instances. It even allows comparisons of immutable properties (the one whose TypeConverter's CreateInstanceSupported returns true) having different values.
Displayed values (set by PropertyValue.ResetDisplayedValues or by the PropertyValueDisplayedAsAttribute) are more flexible. Before you could only set them as strings. You can now supply objects or pairs <object, string>.
Trackbars now accept to target integer, float, double and decimal property types.
Ctrl+Enter in a multiline textbox inserts a new line.
By default, a listbox uses the same visuals (font, fore and back colors) than the property value. It is now possible to break this synchronization and let the listbox use the normal colors used by the grid. This is done by using the DropDownListboxVisuals attribute.
The List feel can use a cache for properties showing a costly content that should not be recreated each time the listbox is displayed. To configure a property in such a way, mark it with UseFeelCacheAttribute. The cache can be emptied by setting PropertyValue.FeelCache to null.
The Unit inplace control now takes into consideration a unit with a single value (a collection with a unique possible value or a simple string). In this case, no dropdown is shown and the value is just displayed as a static information.
For list feels, the resize box can be removed by setting the PropInPlaceList.PreventResizable to true (from the InPlaceCtrlVisible event handler).

I hope you will like this this verson as much as I worked on it. If you have any question, if you are not sure what SPG can do for you or if it does a particular thing, don't hesitate: contact me.

Trackbars for any numerical value in Smart PropertyGrid

This was a long time requested feature: being able to attach a trackbar feel to any type of numerical value. As a last minute surprise in SPG 2.5 (which is in beta), I implemented it for integers, floats, doubles and decimals (it’s ready for more but let’s see what you actually need in the future). The feel still needs a PropertyValidator attached to it so that it can have the minimum and maximum values. There is also a new attribute (TrackBarSettings) to set the Resolution (new notion for floating point numbers) the SmallChange and LargeChange properties.

Since at the same time, a customer had troubles with a property of type PointF and its associated TypeConverter, I updated the sample with such a property showing the new trackbar for the X and Y child properties. Here is a screenshot of this nice arrangement:

If you need the PointF TypeConverter, feel free to download it. It is simply based on its counterpart for the Point structure.

How to filter out base classes properties from the PropertyGrid

I like to post some howtos or tips when the initial concern comes from a customer or visitor. One of them in the forums asked if it was possible to filter out properties while using SelectedObject and even if all properties from ancestor classes could be removed automatically. Well, yes, it’s feasible in Smart PropertyGrid. This is very quick. Here is how:

Let's say you have a class MyControl derived from the Control class.

You must first add a handler for the PropertyPreFilterOut event or simply override OnPropertyPreFilterOut in a PropertyGrid derived class:

protected override void OnPropertyPreFilterOut(PropertyPreFilterOutEventArgs e)
{
    // Write some code here
    base.OnPropertyPreFilterOut(e);
}

Now to remove all the properties coming from ancestor classes, we must pay attention to their PropertyDescriptor and target instance so that we keep all properties published by our MyControl derived class and all their descendants:

PropertyDescriptor pd = e.PropertyDescriptor;
if ((pd.ComponentType == typeof(MyControl)) || (e.TargetInstance.GetType() != typeof(MyControl)))
    e.FilterOut = PropertyPreFilterOutEventArgs.FilterModes.FilterDefault;
else
    e.FilterOut = PropertyPreFilterOutEventArgs.FilterModes.FilterOut;

Two screencasts to showcase the great support of SelectedObjects

The support for SelectedObjects in version 2.5 of Smart PropertyGrid.Net has been totally reworked. Previously it was rather limited, so I wanted to bring it equal to the Microsoft PropertyGrid and finally it appears it is now far better. It is now possible to select several target instances and to see and edit any common properties even for immutable properties, the ones whose TypeConverter returns true for CreateInstanceSupported(). Add the existing power of SPG, like the numerous editors, and you have a very powerful and flexible way to edit for e.g. the objects you have selected in your CAD/CAM client application.

A demonstration is better than a long explanation so I have created two screencasts (please, bear with me, this is the first time I'm doing it in english). The first one is based on a famous article at CodeProject and the second one uses the great Spread for Windows Forms from FarPoint.

The best way to attach a unit to a numerical value in the PropertyGrid

When you expect your end-user to enter a numerical value in a given unit, you usually want to make this information available near the editor. Entering a value in millimeter or centimeter makes a difference and it is mandatory to clear the ambiguity. In the Microsoft PropertyGrid or in SPG, it could be done like this:

Write this information in the comments area at the bottom of the grid. But what if you don't want to display this area?
Put it in the property label: "Frequency (in Hz)". Not very friendly since usually you like to read the unit after the value.
Use a derived TypeConverter so that you can have the value and its unit in the textbox. But in this case you are obliged to write the converter and you make the user think he can edit the unit.

The next release of SPG simplifies all this by extending the FeelEditUnit inplace control. You just pass the unit to the second value of the property (yes, SPG handles multiple value types per property). It can be passed as a string or as a collection containing only a single element).

When the property is not selected, you see this:

When it is selected and edited, you see a nice readonly unit, still in the value column:

As usual, the unit can be targetted in an instance or added on the fly with a call to AddManagedValue.

Two values in a single DateTimePicker

To set two different dates in an application, e.g. a starting time and an ending time, you need two labels and two editors (as far as times are concerned) as showcased in this Outlook screenshot:

SFPE can reduce the space used inside a single editor and the result would look something like this:

Here is how it's done:

SFPE defines a new DateTimePicker class. But we won't use this one here. It is a convenient class that mimics the API of the Microsoft DateTimePicker so that you get all the benefits of SFPE in a class that won't require you to learn something new. As such, it allows and creates only one FieldPack and this is the FieldPack that holds the value. So we will rely on its base class, called FieldPackEditor. But still the job will be easy:

fieldPackEditor1.JumpToNextFieldOnEdition = true;
    
DateTimeFieldPack pack = new DateTimeFieldPack("'From 'HH:mm");
fieldPackEditor1.AddFieldPack(pack);
pack.SeparatorWidth = 6;
pack.Value = new DateTime(2007, 9, 12, 13, 30, 0);
    
pack = new DateTimeFieldPack("'to 'HH:mm");
fieldPackEditor1.AddFieldPack(pack);
pack.Value = new DateTime(2007, 9, 12, 15, 0, 0);

I first configure the editor so that the editing is minimal. "JumpToNextFieldOnEdition" moves the focus cue to the next editable field when the user is done with the current field. Then I create a first DateTimeFieldPack instance that will hold our first time. The pack is added to the editor and a nice margin is set. At last I create the second pack that will hold the second time value. This is all it takes to get what you see in the screenshot.

Smart FieldPackEditor.Net prices explained

SFPE.Net is due out very soon, so I'm just giving the final touches like preparing the web site, building installation packages and creating license files. I have also finalized the price plan and I wanted to share with you why it looks like this:

I want to emphasize several important points:

Some of you will want to replace the old MS DateTimePicker and that's it. The option starting at 49$ is for you. It is very affordable and not too low (some people think that too low means "no value"). At this price, replacing all your DateTime pickers should be seen as a bargain since you get what you needed (at last you get rid of the MS DTP) + a complete framework the day you want to go a step further.
Let's take now the most popular option "source code with a one year subscription" which costs 99$ for one developer. I chose this price carefully. It is typical of this kind of full featured component and won't scare your company to buy one or more. If you already know the quality of the support I give you, then you realize how much value is packed in this product.
The discounts applied for the volume purchases is also far more aggressive than for SPG.Net. The site license is calculated on a 70% discount basis! My wish here is to make this option so affordable that medium to big companies won't wonder very long if they should purchase the library for their department A but not for department B. By getting the site license at this price you win the peace of mind by being sure that any of your developers can include the component in any of your applications.

Performance hit under Vista ... solved!

Some customers reported the following problem under Windows Vista: when positionning the mouse over the PropertyGrid, the cpu was raising at 100% and as a consequence the grid was experiencing redrawing problems when expanding nodes, checking radiobuttons, etc. I worked this week on this issue and discovered the culprit: VisualTips.

This wonderful component from Skybound was indirectly sending a ton of MouseMove events to the grid (and to any control on the form). The cause of this behaviour has not been found precisely but the people there fixed the bug related to another 100% cpu symptom. If you are using VisualTips and your product also targets Windows Vista, you have to get their update.

VisualHint’s web site has been reviewed by Bob Walsh from 47hats.com

As a customer or visitor of this web site, this is maybe not the post you wish to read. It won’t talk about PropertyGrids, DateTimePickers or other editors but about the design and the life of this web site. As a micro independant software vendor (aka mISV) and specialist of software development it is sometimes difficult to create a good website, attract customers with perfect descriptions and screenshots of products as well as interesting and relevant informations. On the other hand it’s very easy to loose the focus on all of these while writing C# code to enhance or create products. That’s why some time ago I asked Bob at 47hats to include VisualHint in his weekly review of mISVs web sites.

Bob owns a "mISV type" company and he even wrote a book about it. He is now considered an authority in this domain and launches a consulting firm to help independant workers like me. Last week, he informed me that the review for VisualHint was in the work and here is the result: review at 47hats.com.

From this review, I keep the following criticisms:

SPG.Net is not correctly introduced.
Its important features, your benefits, are listed too deeply in verbose text.
My english may be suitable to talk to you in a blog must not for the business part of the web site.
Where is the testimonials page?

Of course I also read positive elements which confirm the qualities of VisualHint:

The web site is very pleasant to read.
My second product, Smart FieldPackEditor.Net has been introduced correctly, especially with the help of screencasts.
The support given to customers, as it appears on the site, is excellent (it is also excellent when I actually give support).
This is honest to introduce VisualHint on the about page the way it is really: driven by a passionate developer.

From there, I have to plan the changes that I will bring to the site (the testimonials page has already been added). This will mainly concern the spg.net product and the level of written english. If you have your own view on what is missing or badly shown, don't hesitate to add it in the comments.

A true IP address control for windows forms

Some days ago, I was asked by a visitor if it is possible to edit an IP address in Smart PropertyGrid with a specialized editor. The short answer was no. But then I realized that the FieldPackEditor would make a wonderful IP address editor. So I derived a new editor from the base class, created special IpAddrSegmentFieldPack and IpAddrSegmentField classes and voila!

Like with other field pack editors, you can show updown buttons, handle a null value, have fixed-width fields or not, set the Text and Value properties and use all the usual keys to edit the address. I think this is the first time we have a so complete IP address editor for windows forms (let me know if there is some competition). You can now play with it in the updated sample and you will see it soon in the PropertyGrid too.

A new year begins for VisualHint

Yes, this is like a new year beginning here. I was in vacations in France during three weeks for a break from VisualHint, with family in Normandy by the sea not far from the american cemetery for those who know this place. This was very relaxing and the kids had a lot of fun with the beach activities (when one lives in Montreal at four years old, the sea is something new). Now that I'm back, this is time to take stock of the VisualHint's future. So how is it going here you will ask. Here is the short answer:

I highlighted May 2006 because at that time I posted a message titled Incredible month of May. You can now see the comparison with my last recorded month. This has almost doubled, so yes, I’m very happy about the evolution of Smart PropertyGrid.Net and its sales. Notice the two spikes, one downward from the mean curve and one upward. The first one is August 2006: activity was very low and I also took some vacations. The second one is November 2006: I can’t really explain it but it seems like a lot of companies wanted to do their shopping before the month of December and Christmas.

So now what? It took me up to today to almost clear all the cutomer requests received during my absence. Still a few ones and I will be done. All the fixes generated will be available very soon in a maintenance release, I guess sometime next week. Then I will come back on the new FieldPackEditor product to finalize it and take it out of beta. Once done, it will be time to define the major new features of SPG v.3. I think the summer break with its low activity will be a very good time to do that. For those who take their vacations, I wish a lot of fun and rest.

More about null values in a DateTimePicker

Before releasing version 1.0 of Smart FieldPackEditor.Net I must ensure that the support for null values is really complete. So what does this feature really involves?

First let’s remind in what contexts a DateTimePicker can operate:

It can be a standalone control and completely encapsulate a DateTime value.
You can manually bind one of your properties to the component’s Value property.
You can embed the component in a container like the DataGridView. In this case, the component will be automatically bound to a particular column of a database table via a DataSource.
You can embed the component in a container like the PropertyGrid. This will bind the component to a DateTime property somewhere in your code.

In the first case, the support for null values is straightforward. The component stores the DateTime value as an object so it can use anything for the object representing a null value.

We have to think a bit more for the other cases. What can be the type of your property in a target instance? Obviously this can be an object (not very common to store a date but still feasible), a nullable DateTime (aka “DateTime?”) or a DateTime. In the first case, there is again no difficulty: we can assign anything we want to represent a null value. In the second case we have less choices: it can be null or a particular DateTime value that is out of the bounds specified by the MinDate and MaxDate properties of the DateTimePicker (anything before 1753 will be fine). In the last case, with a DateTime type, there are no choices: you can only use a specific DateTime value like 01/01/0001 for example.

Now let’s relate the context of use with the data type you have in your client application:

In case 2, you can target any of the three data types we just saw. The value representing null will be chosen in accordance with the restrisctions seen above and setup in the editor. In case 3, the value representing null will usually be DBNull.Value. But for historical reasons you may have a specific DateTime value in your database that represents the null value. In both cases, again, the editor must be setup for that. In case 4, well, it’s like case 2.

Everything that has been mentioned so far implies that we need a set of properties to properly setup the DateTimePicker:

NullValue: instructs the editor about what will represent a null value. It will typically be null, DBNull.Value or a specific DateTime value. But it could also be a string like “nothing”.
NullText: the string displayed in the editor when Value == NullValue.
HasValue: convenient property to test for nullity.

If you use the DateTimePicker in other very specific contexts and you need support for null value, please let me know.

Right To Left languages support in Smart DateTimePicker acclaimed!

Even so Smart FieldPackEditor.Net is still in early beta, I received this week-end a message from a developer working at a big israelian company about the support for Hebrew. Here is an excerpt:

I examined the control and let me tell you it is very professionally designed and implemented; way to go! Also the RTL and Hebrew are working great, a feat not easily performed by many professional companies.

Supporting RTL is something new for me and when I designed the component I even hadn't the RTL languages installed on my machine, so this message is a real reward for me. Now I know that the code I produced was not just a shy attempt to see if RTL languages could be handled. They can! And needless to say that I am armed to prepare the RTL support in Smart PropertyGrid.

This developer also sent me some great feedback about the sample application. That's why I fixed some issues over the week-end and republished a new build of the beta package.

PropertyGrid, SelectedObjects and the property cloning syndrome

Time permitting, I sometimes haunt the newsgroups and developer forums to help when the PropertyGrid is involved. Last week, a poster noticed a very subtle issue concerning .Net 1.1 and .Net 2.0 and I decided to know more about it. It appears that the MS PropertyGrid behaves differently in these two versions of .Net. Here is an excerpt of the original request for help:

... When there are multiple objects selected, and an object property value is changed in the grid, it is assigning the same object instance to each of the selected objects in .Net 1.0, but in .Net 2.0 it is assigning different instances...

The poster also noticed that the culprit was the method SetValue in the MergePropertyDescriptor class. In .Net 1.x it was simply calling PropertyDescriptor.SetValue() with the same new instance for the target properties but in .Net 2.0 it tries first to make a copy (except if we have a value type) by trying different techniques in a method called CopyValue:

Clones the value if its type implements ICloneable.
Creates a new copy of the value by calling the constructor of its type if the attached TypeConverter can convert to InstanceDescriptor.
Creates a new copy of the value by first converting it to a string and then back to an instance of the value type.
Creates a new copy of the value by serializing it into memory and deserializing it to an instance of the value type if, of course, the type implements ISerializable.

If all tries fail, then the original value is returned.

My thoughts about this issue is that the behavior should be chosen by the developer. In some cases we will want to assign to the target properties distinct instances of the same value and in other cases it makes more sense to assign the same value as if it was a kind of singleton. I tend to prefer what .Net 2.0 does but hey, having the choice is better. I will check if I can offer this choice in SPG, which so far behaves like .Net 1.x.

With the MS PropertyGrid however, I first thought that there was no solution since CopyValue can't be bypassed. But there is one. Implementing this solution for every property would be tedious but for just some of them, when you want to avoid a multiplicity of instances for cost reasons, this can be useful. Attach a TypeConverter to the type of your property (this won't work if it is attached to the property itself) and override the ConvertTo method so that it will convert to an InstanceDescriptor class. In the class corresponding to your property type, add a static method that will be responsible for supplying a unique instance per possible string representation (it could be done elsewhere like in the TypeConverter itself). In the converter, the InstanceDescriptor will point to this class method.

An example is better than a long explanation so here is a short sample.

Note: this solution won't solve the problem of the original poster unfortunately because for him this happens at designtime and the TypeConverter, quite complex, can't be modified. However, at runtime, it can help in a variety of cases.

Screencast 4: a FieldPackEditor is not just for dates and times

To conclude this series of videos, I'll show what can be done with the editor base class. Everything is inside to handle a set of packs and fields which can edit any predetermined data. And since a field is pretty abstract (after all, this is just a rectangle in which we can draw), I'm sure that some nice scenarios will appear after the product is released. Anyway, here is the show:

If there is no last minute drama, the beta will be available next week. If you want to be informed, simply monitor the rss feed or subscribe to the mailing list on the homepage. And of course, feel free to leave some comments here.

Screencast 3: Databinding and the DataGridView

In this third video, I show several features of the FieldPackEditor: how flexible it is to bind a DatTimePicker to a data source, how independant field packs in the same editor can be bound to different sources and how the editor can be used in the DataGridView as a perfectly well integrated inplace control. Keep in mind that this editor will also be compatible with Smart PropertyGrid.Net and integrated in place in its value column.

Screencast 2: three different ways to nullify a DateTimePicker

Just before the beta is released I will publish each day of this week a screencast to showcase the main features of Smart FieldPackEditor.Net.

Here is the schedule for this week:

Tuesday, overview of the FieldpackEditor.
Wednesday, how to handle the null value.
Thursday, SFPE, data binding and the DataGridView.
Friday, multi packs and other editors.

Here is the second screencast of the week. It will show you how SFPE can nullify the underlying value and how it can restore a valid datetime value. Click on the screenshot to launch the movie.

Screencast 1: a full featured DateTimePicker

Just before the beta is released I will publish each day of this week a screencast to showcase the main features of Smart FieldPackEditor.Net.

Here is the schedule for this week:

Tuesday, overview of the FieldpackEditor.
Wednesday, how to handle the null value.
Thursday, SFPE, data binding and the DataGridView.
Friday, multi packs and other editors.

Here is the first screencast of the week. It will show you various general features of the FieldPackEditor derived as a DateTimePicker. Click on the screenshot to launch the movie.

Solving all the issues of the DateTimePicker inside the DataGridView

Some days ago I came across a blog showing the trials and tribulations of a developer trying to display and use the standard DateTimePicker in the DataGridView. This story is really typical of all the considerable efforts one have to make in order to get a semi-viable solution. So far I was not even considering touching the DataGridView. It was an unknown component to me and I was not aware of its extensibility to enable custom editors to be used in a cell. After readind this article I jumped on the challenge and decided to integrate Smart FieldPackEditor.Net to the grid.

While SFPE is not even in beta yet, it took me one day to get almost everything running smoothly. By everything I mean:

Nice insertion of the editor inside a cell. No text shift. Back and Fore colors of the cell used by the editor.
Correct formatting of the datetime value.
Null values without a hitch.
Default keyboard handling.

Some nice features can be added to this list, making the use of this DateTimePicker as smooth as desired:

Correct field selection when clicking in the editor.
End of edition forced when closing the dropdown month calendar.
No fixed width fields, so that the text displayed by the grid is the same than the text displayed by the editor.
Choice of updown and/or dropdown buttons
And all the other benefits of the Smart FieldPackEditor…

As early as Tuesday 22, I will publish each day a series of four short screencasts. Here is the schedule:

Tuesday, overview of the FieldpackEditor.
Wednesday, how to handle the null value.
Thursday, SFPE, data binding and the DataGridView.
Friday, multi packs and other editors.

How to setup a truly dynamic combobox in the PropertyGrid?

SPG offers some great ways to build dynamic properties. But often this is a mix of declarative code and dynamic calls to the SPG API to alter the content or the behavior of the grid. However in some cases a complete dynamic solution is needed. For example, some classes may be generated by external tools and it’s impossible or not desired to decorate their properties with attributes. In other contexts, enumerations are not welcome because their content is too ... hardcoded. This article proposes a way to setup a property based on a single integer identifier and a collection of strings to display in the combobox. To make it a little more complex, our combobox will be the unit of another numerical property.

The first thing we need is a new TypeConverter to instruct the grid that we have a set of values to display in a combobox. The two involved methods to override are GetStandardValuesSupported() and GetStandardValues(). Of course we will derive our converter from the Int32Converter. Here is the code:

public class MyIntConverter : Int32Converter
{
    public override bool GetStandardValuesSupported(
        ITypeDescriptorContext context)
    {
        return true;
    }

    public override TypeConverter.StandardValuesCollection
        GetStandardValues(ITypeDescriptorContext context)
    {
        return new StandardValuesCollection( ??? );
    }
}

Notice the question marks? This is where you pass the allowed identifiers for your list. There are several ways to get a dynamic list from the TypeConverter. For example you could use the passed context (which in SPG is of type PropertyTypeDescriptorContext) to get the list from the target instance. Here we will create a new attribute that will contain the initial list of integers. The definition of this attribute could be:

public class AllowedIntsAttribute : Attribute
{
    public int[] AllowedInts;

    public AllowedIntsAttribute(params int[] allowedInts)
    {
        AllowedInts = allowedInts;
    }
}

GetStandardValues can then be written like this:

public override TypeConverter.StandardValuesCollection
    GetStandardValues(ITypeDescriptorContext context)
{
    PropertyTypeDescriptorContext c = (PropertyTypeDescriptorContext)context;
    AllowedIntsAttribute attr = (AllowedIntsAttribute)c.OwnerPropertyEnumerator.Property.
        GetValue(PropertyUnitLook.UnitValue).GetAttribute(typeof(AllowedIntsAttribute));
    return new StandardValuesCollection(attr.AllowedInts);
}

And here is how all is connected when the grid is filled:

propEnum = AppendManagedProperty(rootEnum, _id++, "Width", typeof(int), 2, "");
propEnum.Property.Look = new PropertyUnitLook();
propEnum.Property.Feel = GetRegisteredFeel(PropertyGrid.FeelEditUnit);
    
propEnum.Property.AddManagedValue(PropertyUnitLook.UnitValue, typeof(int),
    10, new AllowedIntsAttribute(1,2),
    new TypeConverterAttribute(typeof(MyIntConverter)),
    new PropertyValueDisplayedAsAttribute(new string[2]
        { "feet", "meters" }));

If the list of identifiers and the list of displayed strings need to be modified, this is possible in SPG. Attributes set dynamically can be accessed with PropertyValue.GetAttribute() and modified if their API enable to do so.

I hope you will appreciate this tutorial. If something is unclear or you need more explanations, please leave a comment.

How to set a null value to a DateTimePicker without any compromise?

Just to make it clear that this is the first concern about the MS DateTimePicker, here is a list of famous links:

These articles all try various tricks to create a nullable DateTimePicker. Unfortunately, while the intentions are good, it does always create secondary issues (look into the comments). SFPE will naturally support null values but from a user point of view the path to set null can still be debated. There are two questions:

How does the user clear the control and hence puts null as the value?
How does the user inputs a new non null value when the current value is null?

SFPE is flexible so a lot of techniques can be implemented. But before writing here the result of my experiments (I don’t want to influence your ideas), I would like to hear from you in the comments what would be your perfect solution. Don’t limit yourself to what the MS DateTimePicker could do. Forget about it! Just try to imagine the best answers for the two above questions. This “perfect solution” could then be kept for the default mechanism in SFPE.

How to format a number with a specific CultureInfo/NumberFormatInfo in the PropertyGrid ?

“How to format a number in the PropertyGrid” is a question that I’m often asked. The following answer is valid for the MS PropertyGrid and for Smart PropertyGrid.Net. Therefore it is not in the SPG documentation.

The following explanation will be given for a Double number. You can easily apply it to a Single or a Decimal. If your target instance has a Double property, it uses by default the DoubleConverter TypeConverter. Unfortunately (for the present need) this converter uses the “R” format specifier when it converts from a double to a string in the ConvertTo method and the NumberStyles.Float style when it converts back a string to a double in the ConvertFrom method. “R” is called the round-trip format and it does not use the culture set for the application. It’s useful to ensure that a double converted to a string will result in the same original double when converted back.

It means that to solve our problem we must define a new TypeConverter and attach it to our Double property. We can derive it from DoubleConverter but we will override the ConvertTo and ConvertFrom methods. Here is the code of this converter:

public class MyConverter : DoubleConverter
{
    public override object ConvertTo(ITypeDescriptorContext context,
        CultureInfo culture, object value, Type destinationType)
    {
        if ((destinationType == typeof(string)) &&
            (value.GetType() == typeof(double)))
        {
            double num = (double)value;
            return num.ToString("N", culture.NumberFormat);
        }

        return base.ConvertTo(context, culture, value, destinationType);
    }

    public override object ConvertFrom(ITypeDescriptorContext context,
        CultureInfo culture, object value)
    {
        if (value is string)
            return double.Parse(value as string, culture);

        return base.ConvertFrom(context, culture, value);
    }
}

To set a specific culture usable by the PropertyGrid, you can change the global culture of the application. For example:

Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-us");

In SPG.Net you have also another option. You can set a CultureInfo instance per property. If you don’t, it will use the one of the application. This is useful for example to display numbers with various precisions or different currency formats.

protected override void OnPropertyCreated(PropertyCreatedEventArgs e)
{
    PropertyValue propertyValue = e.PropertyEnum.Property.Value;

    if ((propertyValue != null) && (propertyValue.UnderlyingType ==
        typeof(double)))
    {
        e.PropertyEnum.Property.Value.CultureInfo.NumberFormat.
            NumberDecimalDigits = 6;
    }

    base.OnPropertyCreated(e);
}

The ten deceptions of the DateTimePicker

If you are here reading these lines it’s because you have something against the .Net DateTimePicker. And you’re not alone since, if you do a search in the newsgroups, the same questions keep coming: “how do I set the background color of the DTP?”, or “it does not accept a null value and my DateTime column in my database has some empty cells”.

CodeProject and other similar developer communities give you a lot of pseudo solutions to solve one or two issues of the control… when they don’t create new problems. They start with deriving from the DateTimePicker class and overriding certain methods and end with the magic textbox displayed in front to hide the date value when null is the only thing desired. So it’s obvious that everyone complains about the DateTimePicker shortcomings and everyone needs a solution. What are the problems of this component which is, don’t forget it, the underlying win32 SysDateTimePick32 window class, nothing more:

The complaint number one is that it doesn’t accept a null or DBNull value. This is critical when binding it to a nullable DateTime column in a database. Consequently it’s not possible to display a custom string when this value is null.
It suffers some display issues: when closing the calendar, the focus cue disappears, except if a checkbox is visible, in which case this is the one taking the focus. Speaking of the checkbox, it will sometimes show this cue even when the control itself is not focused. No mouse hover effect is seen on the dropdown button and checkbox, however there is one for the updown button. And don’t ask me why you can’t show an updown button with a dropdown button at the same time…
There are also some inconsistencies compared to the usual combobox and checkbox controls. When clicking those buttons, the corresponding action is triggered on mouse down instead of being triggered on mouse up.
If you disable the date by clicking on the checkbox, which is by the way ridiculously small under a non xp theme, clicking the dropdown button instantly reenables it.
There is no text formatting options except for the month calendar. The background color can’t be set.
Programmatically you can’t control which field is the selected one.
This is the same for the dropdown calendar. You won’t be able to show it or hide it without the user intervention.
Some people would like a way to automatically jump to the next editable field when all characters have been typed in the current field instead of having to type the right arrow key each time.
Where are callback fields? Do you remember the DTN_FORMATQUERY and DTN_FORMAT messages? It was great to create custom fields but this feature is not natively present in the .net control.
No custom culture can be applied on the displayed string. The Microsoft KB says it clearly: you can do it only by changing the current culture in the control panel. Pretty annoying for applications that want to change this regional setting on the fly, usually when choosing a language in a preferences box.

There are some more issues that I had, specifically in Smart PropertyGrid.Net. Among the built-in inplace controls this was the only one to vertically align the text at the top. No way to change that. When a property expands on multiple rows or simply increases its vertical margin this is not very nice. Also, a field calculates its width based on the largest string it can accept (“September” for the month for example). This was also an issue with SPG. When the inplace control was not active, I had no way to display the text with the same spacing between fields and therefore when selecting the datetime property, all the fields were shifting in a non pleasant way.

I guess there are some more concerns that you encountered while coping with the DateTimePicker. You can add them in the comments so that we have a good starting list to know what else needs to be fixed.

The perfect DateTimePicker? Not only!

It is well known that a good product is one that provides a solution to your own problem, and as a result would meet the needs of a wider audience. Some time ago I discovered a problem in SPG.Net. I couldn’t make a true DateTimePicker inplace control achieving the level of quality of the overall product. The win32 control from Microsoft has so many issues and inconsistencies that it was a nightmare trying to work around them. Finally I decided to remove this inplace control from SPG and announced it to my customers. I was really dissatisfied by this decision but I had no other choice. Time passed and I was still sure there was nothing I could do about it. I then came to the conclusion that I could rewrite a DateTime picker from scratch but at first I was discouraged because I didn’t know where to start.

This is quite typical. Let time go by and one day you find the courage. I began slowly, one small thing at a time and sooner than expected I had a base control to work with. Instead of tying it to datetime specific requirements, I made the effort of designing it as a generic editor able to edit a series of rule-based fields, a rule being for example “an integer in a specific range”. Smart FieldPackEditor was born but it didn’t know it yet.

I was whispering to myself “it would be great if it could be a standalone product but I guess that many component vendors, and especially the big ones, have already covered this domain”. Guess what? No! I found absolutely no “field editor” controls and concerning DateTimePickers I found only two but one seems to emphasize only a vista look and feel, while the other one was so basic that I can’t even remember who offered it. All the other possibilities are in the “free” domain, mainly on CodeProject. They all derive from a DateTimePicker or a TextBox and try to do their best to fix one or several issues of the MS DTP but the result is never the perfect solution.

So, in essence what are the goals of SFPE:

To be the best (if not unique right now) DateTimePicker replacement of choice for the old MS DTP.
To be a generic framework able to let a user edit a set of fields where each field is governed by a rule.
To be extended via a derived class so that it is fully usable in SPG.Net and therefore will fix my initial problem.

I need your input to make this product an absolute must. So I have opened a new section in the forums and a mailing list on the homepage (so that you can be informed when the beta begins). Given what I wrote above, what do you think ? What are your features of choice ? What are the issues you want fixed first?

In a next post, I will try to summarize all the problems of the MS DTP and expose how SFPE fixes them.

A new home for VisualHint

VisualHint has reached another milestone. Today, I’m launching my new web site that offers the GUI components that I design. The redesign was not out of boredom, but simply the result of a need to support more than one product. The previous site had been designed around a main product (Smart PropertyGrid) and the accompanying news section and I had no idea how to add another product which would have the same importance. Therefore, it was time for a redesign.

I took Xara Xtreme Pro, a very nice tool to quickly output vector drawings and began coding css and html pages. I must admit it was quite long for me because I’m not a web designer, but I like the process of being fully involved in the construction of my new home. That being said, I hope you will like it, as much as I do. Btw, here is a list of what changes were made during the redesign:

The previous blog was more a “news section” than a blog. I will now try to maintain a true blog discussing PropertyGrids, DateTimePickers and custom controls in general.
Comments and trackbacks are open for more communication with visitors and customers.
The homepage clearly presents the products, the latest announcement and the latest blog post.
The navigation is easier than before.

So now you would like to know more about this new product, is that it? To be followed on the next post…

Value validation in great form

So far, value validation in SPG was simple and clean: no annoying popup but also the obligation to see the previous value automatically restored.

For the next release, value validation is being reworked. It will still offer the existing behavior but also a mode called KeepFocus. Under this new mode, the focus stays on the faulty value until the user types a valid value (this is what happens in the Microsoft PropertyGrid but unfortunately spoiled with the modal popup). Inside a new validation callback the client application will be given the choice to display a visual clue to indicate to the end-user that there is a problem. The best option will be to show the free Skybound VisualTip.

Here are two examples grabbed from my current build. In the first situation, an event is sent to the client application and indicates that a TypeConverter was not able to convert the value set by the user. The text of the exception is passed with the event and the client application made the choice to display it in a customized tooltip.

In the second situation, the user entered a value out of the range set by an attached PropertyValidatorMinMax class. The validator proposed a generic text but the client application made the choice to display a custom text.

I must add that the visual capabilities of VisualTips are endless. Very nice product. Marry it with Smart PropertyGrid.Net and you succeed bringing the right experience to your end-users.

PropertyValueChanged for collections bug fix

I was not aware of this bug in the Microsoft PropertyGrid until a customer told me it was doing the same thing in Smart PropertyGrid. This is interesting enough to add a post here about it. The issue is that PropertyValueChanged is not fired for certain collections. It works with an array but doesn’t for a List<> for instance. The reason is that the UITypeEditor.EditValue(...) method returns the reference on the original collection even if its content has been modified. I looked in Reflector and after this method returns, the Microsoft code does a simple “if (obj1 != obj2) ...” which of course returns false and doesn’t trigger the event. My code was actually doing the same thing, so I fixed it to handle this particular case. This is another reason to purchase from a small company that reacts and makes a product that evolves fast. This enhancement is available in version 2.1 beta2 that is out today.

A website for PropertyGrid resources

I launched today a new web site, minimalist in page count, intended to .Net developers who use the Microsoft PropertyGrid (and secondarily Smart PropertyGrid.Net since it understands all the framework classes related to Type discovery). Because this is sometimes difficult to get the right information for developers who start using this complex component, it seems it was essential to have a well known page referencing all famous and less famous articles, forum posts and other various materials. I don’t want to spend time on developing the web site itself, but surely want to enrich its content with my findings and your submissions. Even nice tips and tricks can fit there. The address is www.propertygridresourcelist.com.

Navigate with the TAB key in a PropertyGrid

This feature is one of the most discussed about PropertyGrids in general, whether they are mfc, activeX or .net controls from third party developers. The model provided by Microsoft does not offer the possibility to navigate from value to value with the TAB key, or shift+TAB for reverse order and this is a lack that annoys a lot of people. One of my customers had a long discussion with me about this feature. He wanted absolutely this kind of navigation to help his end-user edit a long list of mandatory variables. Using Return and Escape plus the arrow keys was not enough to provide a good experience to his own customers. Since that time, several other visitors and customers asked me the same feature. After visiting some developer forums and articles, I was convinced that browsing property values with the TAB key would be a must for Smart PropertyGrid.Net. So here is what I came with:

You are now able to choose between two major modes. In the first one you need to validate or cancel the current edition of the value and use the arrow key to go to the next editable property. In the second one , you navigate to the next inplace control with TAB and to the previous with shift+TAB. There are also several non-exclusive options for all tastes:
The "TabKeyWithAutoFocus" option will focus inside an inplace control as soon as you click on a property label. This is a great way to minimize the actions required by the end-user.
The "TabKeyInSubControls" option will allow to access child components in inplace controls. For example, for a trackbar feel, TAB will first go in the textbox part and another TAB will jump to the slider.
The "TabKeyInChildProperties" option will open any collapsed hierarchy to place the focus in the next editable property value.
The "TabKeySkipReadonlyProperties" option will skip readonly properties. Without it, these properties are visited so that a clipboard copy operation is possible while navigating the grid with the keyboard.
At last, the "TabKeyLeavesAtExtremes" option will normally tab to the remaining controls in a form once the top or bottom properties are edited. Without it, the focus will continue to rotate in the PropertyGrid.

There will be a small sample available to showcase all those modes in a few days.

SelectedObjects ... with a final ‘s’

Since the release of the major version 1.5 with the support of Microsoft UITypeEditor classes is not far away and because many people are asking:

Yes, SelectedObjects allowing to select multiple target instances in the PropertyGrid is the next major feature to be developed. Once done, this should definitely show that Smart PropertyGrid.Net has now an extensive list of features and can be used as a stable base for even more enhancements in the future.

The next major feature

"Smart PropertyGrid.Net will now support Microsoft UITypeEditors (dropdown and modal), the built-in ones provided in the .Net framework as well as the custom ones you have created."

In this post I wanted to announce that I was working on the first of the next major features available in SPG.Net 2.0. But this is a feature that many people requested and therefore I will answer to this wish by creating shortly a version 1.5 that will integrate it, even if officially this is a "2.0" feature.

The reason to add support for "legacy" (hehe, sorry, couldn’t resist) Type Editors is that my customers often take time to migrate their application to the new way SPG is working. In fact every client application using SPG should reasonnably stop using SelectedObject but I understand time and budget constraint matters and to allow easy switching between the Microsoft PropertyGrid and SPG, UITypeEditors must be fully handled.

If you have any questions or specific needs related to Microsoft UITypeEditors, please contact me and we will discuss while this is still in the works.

Incredible month of May

I would like to thank all the companies and individuals who suddenly transformed nice sales into a tremendous success. The month of May has been outstanding in terms of sales. As a consequence, my helpdesk system is also showing more and more messages from all of you. I get some "thank-you" for this unique product alongside the Microsoft PropertyGrid, I get new feature requests and also troubleshooting and problem reports ... all the things that will make Smart PropertyGrid continue to grow and become always more stable. Just to give you an idea, here is a blind graphic of my sales since last November:

As you can see the first day of June just looks very promising... This chart can be read in terms of income or in license count. It doesn't show the full site licenses since they are an infinite number of licenses for a company site.

What is coming next?

So far everything is going well with the release of Smart PropertyGrid.Net. No major bugs were reported and each minor bug is fixed the same day it is received. Version 1.0.2 is on its way to bring you the latest updates. The sales are also promising and the last sale being a full site license with one year support allows me to see the near future with confidence.

Concerning the management of VisualHint, first I have chosen a design company to do the new web site. Production may begin next week. I will also buy a script (still in development) that handles customers, licenses and downloads far better than now. Furthermore it should integrate perfectly with the CMS I’m using. And at last, the addition of an helpdesk software will be a true benefit for me and my customers. Bugs and feature requests will be managed efficiently and it will support documentation books and a knowledge base. As far as documentation is concerned, this is still a weak point. But I am working on a tutorial, kind of quick start guide, that will be available during the first week of April.

This year will be the real expansion of VisualHint and I hope that you will be part of it.

Countdown to the release of Smart PropertyGrid 1.0

You were waiting for this one I’m sure: "Smart PropertyGrid.Net 1.0 will be out some time next week". I have no known bugs in the queue and it makes now several days that nobody is reporting some glitches or whatever that could delay the release. That’s why I wanted to make this pre-announcement so that you can still benefit from the current discount (I remind you that it entitles you to buy any additional licenses and subscription renewals at the same discount during your initial subscription, except for full site licenses). After next week, the price will come back to 159 USD for one single license and the subscription of current customers will start.

Also note that the price plan has been updated and is now final. A 10 licenses pack has been added and definitely clearer discounts applied, giving finally lower prices.

Icons for the combobox

Per user request, I added as a built-in feature the possibility to attach images to the elements of a combobox. Before, it would have been possible to achieve such effect but by deriving from several classes. Now the effort for the developer is minimal and just needs to attach an ImageList to a property Value. Here is an example:

284

This is the number of registered people who have tried Smart PropertyGrid beta. I am quite impressed by this figure and for sure I was not hoping so much interest, even if I think that if companies want to display a PropertyGrid in their application it should definitely be something more user friendly than the Microsoft grid that has been designed for developers.

Now this is very difficult to say what sales will be. Do people come by curiosity or do they actually intend to purchase such a product ? At least I have exclusively very good feedback and I am quite confident for the future because Google Analytics gives me a comfortable and increasing rate of revisits.

Price plans

Price plans have been defined and are as follows:

Initial subscription (30 days) with sources: 1 license = $159 ($127 for a limited time) 5 pack = $755 (5% discount) 10 pack = $1,429 (10% discount) 20 pack = $2,544 (20% discount) Full site = $5,959 (25% discount) You can mix the packs to obtain the appropriate number of licenses.

Initial subscription (30 days) without sources: 1 license = $99 5 pack = $469 (5% discount) 10 pack = $891 (10% discount) 20 pack = $1,584 (20% discount) Full site = $3,712 (25% discount) You can mix the packs to obtain the appropriate number of licenses.

Yearly renewal for support and updates: The formula is simple: you pay half what you paid for the product, and if you purchase the renewal during a valid subscription, you get an additional 30% discount. For example, a 5 pack renewal purchased in time would cost: (755 / 2) = 377 - 30% = $264

Consulting for the implementation of custom lool/feel/inplace controls classes will be available and will be quoted on request.

The versatility of the Checkbox'ed property

When the user wants to select some values from a definite small number of choices, attaching a checkbox look/feel to the property is a good way to achieve exactly that, instead of using the usual combobox. Instinctively you may think that only an enumeration type can use such a feature. Actually, three types can.

Enumeration: this is the usual case. You may apply a custom attribute to display the enum values differently.

[Flags]
public enum SupportedOSs
{
    none = 0,
    win95 = 1,
    win98 = 2,
    winxp = 4
}

private SupportedOSs _oss;

[PropertyValueDisplayedAsAttribute(new string[] { "None", "Windows 95", "Windows 98", "Windows XP" })]
public Checklist SupportedOperatingSystems
{
    get { return _oss; }
    set { _oss = value; }
}

propEnum = AppendProperty(rootEnum, _id, "Supported OSs", this, "SupportedOperatingSystems", "");
propEnum.Property.Feel = GetRegisteredFeel(PropertyGrid.FeelCheckbox);
propEnum.Property.Value.Look = new PropertyCheckboxLook();
propEnum.Property.HeightMultiplier = propEnum.Property.Value.GetDisplayedValues().Length;

Boolean: a boolean can be attached to a single line checkbox. This is an extension to the above mechanism to have a convenient way to switch between yes/no, enabled/disabled or such states. This is far more convenient than the traditional combobox. Here again you can customize the displayed strings.

private bool _signalState = false;

[PropertyValueDisplayedAsAttribute(new string[2] { "Signaled", "Not signaled" })]
public bool SignalState
{
    get { return _signalState ; }
    set { _signalState = value; }
}

propEnum = AppendProperty(rootEnum, _id, "State", this, "SignalState", "");
propEnum.Property.Feel = GetRegisteredFeel(PropertyGrid.FeelCheckbox);
propEnum.Property.Value.Look = new PropertyCheckboxLook();

Collection: why to handle collections? Just because you may not know the set of possible values at compile-time. This gives something very easy to manage, like this:

private ArrayList _supportedOSs = new ArrayList();

public ArrayList SupportedOSs
{
    get { return _supportedOSs ; }
    set { _supportedOSs = value; }
}

List stdValues = new List();
stdValues.Add("Windows 95");
stdValues.Add("Windows 98");
stdValues.Add("Windows 2000");
stdValues.Add("Windows XP");
propEnum = AppendProperty(parentEnum, _id, "Supported OSs", this, "SupportedOSs", "",
       new PropertyValueDisplayedAsAttribute(stdValues));
propEnum.Property.Feel = GetRegisteredFeel(PropertyGrid.FeelCheckbox);
propEnum.Property.HeightMultiplier = stdValues.Count;
propEnum.Property.Value.Look = new PropertyCheckboxLook();

Properties with hyperlink

You already know the HotLinkProperty. It lets you put a static text in a row and it looks blue and underlined, inviting you to a click to activate the link. I have added in the latest build, on request, an editable link. Basically this is a normal property that you create as usual but you just add something like this:

propEnum.Property.HyperLinkFormat = "mailto:{0}";

When Ctrl+clicked (for HotLinkProperty or such normal properties), you will receive the event HotLinkClickedEvent and get the complete hyperlink, with {0} replaced by the actual property value.

A new logo for VisualHint

I’m happy to unveil the new VisualHint identity. It is based on the old logo but now features a brand new look that I find far more attractive, dynamic and professional. It precedes the conception of a new web site that will bring together the existing library for MFC and the new one for .Net.

Visual Studio 2005 released

I downloaded a copy of the express edition yesterday and I am happy that the Smart PropertyGrid library compiles well. First tests show no crashes also. I encourage you to continue your beta testing under the official release.

DateTimePicker, PropertyGrid and BackColor wedding

The Microsoft PropertyGrid doesn’t use the DateTimePicker control to edit a date. It uses a simple dropped down month calendar and therefore it is not even possible to edit a time only. This was the indication of a challenge for me.

If you do a search with the keywords "DateTime BackColor" on the web and on the newsgroups you will find a lot of posts asking how to change the BackColor of a DateTimePicker control as well as answers saying that it is not so obvious and that you could try this way and this way. Nothing clear. Since I had not a lot of bugs to fix in the last days, I decided to add the DateTimePicker control as a feel for the first release of SPG. And after several days of pain and despair, I finally got it working and integrated in the PropertyGrid. Here it is: PropertyGrid and DateTime

There was several difficulties. The first one was to show the proper BackColor. Once done, I discovered that when made initially visible, there was a nasty flickering effect. So I had to fix that to get the same quality standard as all the other inplace controls. I did it but the fix was producing erratic drawing when clicking on the fieds of the control or using the arrow keys to change the values. Well, now this is done and I am pretty proud of it.

You can see it in action in the new build 11 and the updated sample application.

How to manage the appearance of a default value

The Microsoft PropertyGrid has a built-in mechanism to handle default values: it displays them by using a non-bold font while the other properties are painted with the bold style. The Visual Studio designer also proposes a menu to reset a property to its default value.

I could have done the same in SPG but this would not be very flexible. Some people, like I did in a C++ application recently, will want for example to display a very subtle different background for non default values. Or maybe you simply want no difference at all. That's why I provide no built-in mechanism at all !!

Therefore I had to show you how simple this is to do it externally. Here is an example that will simply mimic the Microsoft way (the code is placed in a derived class of PropertyGrid):

protected void CheckDefaultValue(PropertyEnumerator propEnum)
{
    if (propEnum.Property.Value == null)
        return;

    DefaultValueAttribute attr = (DefaultValueAttribute)propEnum.
        Property.Value.GetAttribute(typeof(DefaultValueAttribute));

    if ((attr != null) && attr.Value.Equals(propEnum.Property.Value.GetValue()))
        propEnum.Property.Value.Font = this.Font;
    else
        propEnum.Property.Value.Font = new Font(propEnum.Property.
            Value.Font, FontStyle.Bold);
}

// Check the property value against the default value and set the
// font accordingly
protected override void OnPropertyChanged (VisualHint.SmartPropertyGrid.PropertyChangedEventArgs e)
{
    base.OnPropertyChanged(e);
    CheckDefaultValue(e.PropertyEnum);
}

// Set the correct font on the property when it is initially created
protected override void OnPropertyCreated(PropertyCreatedEventArgs e)
{
    base.OnPropertyCreated(e);
    CheckDefaultValue(e.PropertyEnum);
}

Download a sample application

I have published today a sample application. In fact this is my test program that showcases almost every feature of the PropertyGrid. At the same time, I have updated the SmartPropertyGrid assembly to build 2 since a dozen of bugs have been fixed.

Download it now

Multiple values in a row

Here is the third post of the set I promised previously:

To store multiple variables in a single property is a new concept brought by SPG. I wanted to do it when a customer who bought the MFC version asked me if it was possible to have in one row a double value and its associated unit. Although it was feasible with some work it was not instantaneous, and even if this customer achieved to do it I decided to implement a built-in mechanism in the .NET version. And finally this is done. Here is a screenshot from my test app:

It will be demonstrated in the first demo to come.

So, what else can you do with that ? Your imagination is the limit here, but let's see another example. The font dialog is able to let the user choose a color for a font. But the font doesn't store the color. That's why the Microsoft PropertyGrid doesn't manage colors for fonts. SPG can allow you to store in one row a reference to a font and to a color. By writing the right Look class, it can be displayed the way you want (a color box followed by the font text or a colored font text, ...), and it will be edited by a font dialog that enables color selection.

Of course this is not limited to two variables. If you have some built-in arrangements of multiple variables that you would like to see developed in the package, just tell me.

Silence

I’m still here and very active. Because several people asked me the status of the library by mail, here are the very uninteresting reasons of my silence: first some family came here then I took some vacations and very recently I had a major computer crash with data loss. I only got it back from repair some days ago. When everything is restored, I will finalize the evaluation of an obfuscator.

Properties auto-discovery

Here is the second post of the set I promised previously:

The strength of SPG is that you can really work with it at run-time. You will be able to add, remove, move and delete properties with very few lines of code. The appearance and the way to edit these properties can also be changed easily. But to be complete, the existing way of showing properties in the grid has still to be available. Right now, this is done with the SelectedObject Property. It means, among other things, that all the great techniques brought to you on CodeProject by fellow developers still apply to SPG. Here are two of them:

Concerning these two articles, I would like to thank their authors because they helped me, among other sources of documentation, to understand the inner workings of this complex windows forms control. And I'm pretty sure that if I read them again, I will find a small detail that I missed.

But I digress... I used the reflection to find all the custom properties and populate the control. Sticking to the old way is good, but why not to bring a more convenient ease to it. I take the example of a pen. By default, the Pen class publishes a lot of its properties, and some of them are not very useful when you develop a graphical application. "CompoundArray", "Transform", "Brush" only show their class name as value, so why not remove them ? This code will do it:

[PropertyHide("CompoundArray", "Transform", "Brush")]

After removing some properties, it can be beneficial to change the way that some of the remaining ones are displayed and edited. If you have developed your own custom color picker, you would like to assign it to the "Color" property. And maybe you prefer to show updown arrows for editing the pen width. It can be done like this:

[PropertyFeel(new string[] {
"Width", VisualHint.SmartPropertyGrid.PropertyGrid.FeelEditUpDown,
"Color", VisualHint.SmartPropertyGrid.PropertyGrid.FeelList })]

As you can see, all attributes of this kind will take the name of an auto-discovered property as a first parameter. In the example above, pairs of parameters are passed in an array so that it is possible to change the Feel class of many properties. A picture being better than thousands words, here is one:

Short term plans

Sorry not to have posted during several days. Things continue to progress though. The main thing is that I have frozen the development because I am now working heavily on the documentation for the API. NDOC does not fully recognize C# 2.0 but nevertheless I can work with it and preview my progress. Once I am satisfied with it, I will publish an alpha release so that you can play with the PropertyGrid. From the discussion that will result, I will continue the development and create a beta program.

In the meatime, please continue to give me your thoughts and expectations.

Visual C# Express beta2

Just installed it yesterday and everything seems fine with the current code. I had only one compile error and it deals with MaskedTextBox.InputText. This property simply disappeared and this is a real annoyance for me. I currently have a workaround. Let me explain my concern:

In a previous post, I showed an example with a phone number. It is stored as a string variable that doesn't contain the characters of the mask, i.e. 5551234567 and not (555)123-4567. When the user edits the variable I want to retrieve a string without the special characters and InputText was allowing that. My workaround is to temporarily reset the mask to nothing, grab the string and restore the mask, and even freeze the painting during this operation. Please, Microsoft, restore this property, or let me know how elegantly I can do that ;)

Properties and categories sorting

This is a concern often seen in forums or newsgroups. With the Microsoft PropertyGrid, sorting the properties means having to derive from ICustomTypeDescriptor or TypeDescriptionProvider to return the properties in a specific order. Sorting the categories is simply impossible. I think I have to remedy this problem.

First, don't forget the first mode of operation of SPG: in this mode you can dynamically add and remove categories and properties, so by doing that you control the order.

In the more traditionnal way (reflection), we need something very easy for the developer. I was thinking to 2 possibilities. Let me know what you think about it:

Use a new attribute to decorate a property:

[Category("Personal")]
[PropertyRank(1)]
public int MyData { set; get; }

This new tag, "PropertyRank", could be used for categories and properties.

Give access to the collection of sibling child properties/categories for a node and let the user reorder them. It could give something like this:

PropertyEnumerator categoryEnum = propGrid.FindProperty("Personal");
PropertyEnumerator children = MySort(categoryEnum.Property.Children);
propGrid.Reorder(children);

Of course the usual way with ICustomTypeDescriptor must continue to be available.

Appearance customization

Here is the first post of the set I promised previously:

As you all know, the Microsoft PropertyGrid comes in only one flavour, the one I call the DotNet look. It is neat and simple, no point on that. It was even a reference for me when I began coding the version for MFC. But I realized that people wanted more. Some advanced GUI have their own theme and the control should mimic it. In SPG, this is easy. You will be able to choose between some built-in "drawing managers" and you will eventually develop your own one. I did three right now, but if you have a theme that you would like to see in the base package, just let me know. Here is a theme that is used in Sony DVD Architect:

Then come all the small details that make the whole difference at runtime:

By looking at this sample shot, here is what you can do (this list is non exhaustive and may be changed in the future):

Change the color of a property/category label.
Change the color of a property value.
Change the font of a property/category label.
Change the font of a property value.
Add your own drawings in the property/category label area.
Add your own drawings in the property value area.
Assign an icon to a property/category label.

You understand that you can modify every aspect of the control. If you want to show an animated cursor, apply a background effect, and so on ... those are all the things that you can implement.

MaskedTextBox

This is just a short post to say that I have many requests to include the MaskedTextBox as a way to edit properties. I confirm here that it will be available in SPG.

Update on April 7: This is done and here is a screenshot.

First insight

I will in a short time post some articles about specific features of SPG.NET. In the meantime you can already read a list of existing features for the MFC version of the library. Here are the topics I will discuss. They will come with screenshots:

Overall look customization: modifying the overall look of the grid is already described on the VisualHint web site. But I want to recall it here because this is one point that can make your grid really stand out in your product and this is something simply impossible in the standard PropertyGrid.
Auto-discovery: SPG has its own way to use reflection to discover the inner properties of an object instance. First it mimics what the standard PropertyGrid does so that you get what you are used to. And additionnaly you can customize it to show what you really want to show and how you want to show it. An example would be a Pen displayed only as one row, showing a visual aspect of the pen, with only one child property showing the pen width whose content could be changed with a slider or an updown arrow.
Multiple values in a row: Here is really a new concept. Typically a row in the grid is linked to only one data. Now it will be possible to link with any number of data, making possible to represent for example a number (changed with a textbox) and its unit (changed with a listbox).
New attributes: Some new attributes are defined, and many more will be added later, to be able to customize a property without having to write a ton of code.

What can you expect?

You are discovering this web site and of course you are wondering what to expect. What will emerge from all this talk. Let's put it as a shopping list:

A successful and proven design coming from Smart PropertyGrid for MFC.
Plenty of features, some that will make the control work like the existing .NET PropertyGrid, and other new exciting ones that will fill in all its shortcomings, lacks and drawbacks.
A fast evolving product, based on your needs and criticisms.
A top notch support. Your problem is mine and I won't give up until it's solved, even if your subscription is over.
You can get the sources.

This is my goal. Don't hesitate to tell me if I unfortunately diverge from it.

Some questions? Please use the comments so that everybody can watch. You must first register to do that. And by doing so you will also subscribe to a low traffic announcements mailing-list.

This was an evidence...

... I had to blog to show any interested .NET developers that a new type of PropertyGrid is coming. What better tool than a blog could do that? Anyway, I thought it was easy, but when english is not your natural language and when you face a blank window, writing even the most insipid spiel is not obvious.

So just let me introduce myself: my name is Nicolas Cadilhac. I live in Montreal, Canada. I'm creating my own company because I want to dedicate the right amount of time to the products I create. And moreover, people from the .NET side are constantly asking me if I will one day or another port this great custom control to their world. So today, the answer is yes.

There is not real meat here yet, but stay tuned. It will come quicker than you think. The web site also has all the basics to make it work. I will add bit by bit all needed features. If you see something wrong in your browser, thanks to let me know.

And please, for pity's sake, pardon my english and contact me to correct any big mistake or strange turn of phrase you may see.