Hello Good People,

We just released new DotNetBar for Windows Forms 8.6 with over 45 new features and enhancements. This release includes all new Knob, dial control with 4 visual styles.

Here are screen-shots of two out of 4 styles included with new knob control:

Some of the improvements made in latest release:

  • Schedule control now supports time indicators/markers
  • Schedule control now supports keyboard navigation
  • AdvTree now can format cell Text for display using Cell.TextDisplayFormat property
  • AdvPropertyGrid supports PasswordPropertyTextAttribute
  • Schedule control supports custom appointment colors
  • Much, much more… Here are detailed Release Notes.

Thank you everyone so much for using our controls. We are full speed on new features and new products 😉

Hello Good People,
We just released new DotNetBar for Windows Forms 8.6 with over 45 new features and enhancements. This release includes all new Knob, dial control with 4 visual styles.

Here are screen-shots of two out of 4 styles included with new knob control:

Tagged with:

Code-word: Framework

I’ve seen this countless times. You’ve seen it too. Software architecture from hell. The architecture which only purpose is to satisfy itself. Architecture that tries to solve imaginary problem and address imaginary constraints. Too complex and completely unnecessary.

When programmer does not care or do not understand the problem that software is trying to solve, often he goes off and satisfies his need to do something with outrageous architecture. Laziness to investigate actual problem is cause of this. Imaginary software problems get invented so that they can be solved only by an amazingly complex architecture. Look at me, this is some crazy complex code I written!

Please don’t be that programmer. Software is made to make life easier. It is developed to add value. Yes, sometimes complex architecture is required, but more often than not, complex architecture is written because that is path of least resistance… It appears like glamorous work that shows off your amazing skills when in fact, it is complete waste of time. Yeah, I speak from past experience. Guilty on that count. I guess every single developer is too… It is part of growing up.

So how do you recognize this tendency? As soon as you start talking about need to create “framework” watch out! You need framework as much as dog needs fleas. Framework is code word for “I need something to keep me interested in this project”. Framework is code word for “I have no clue or care about problem this software is trying to solve”. It is path of least resistance since it keeps you in familiar territory: code.

Solutions are often far simpler that we are willing to admit, but they require in-depth understanding of the problem which does not start with code…


Today we are releasing DotNetBar for WPF 5.7 with support for Visual Studio 2010. There are also number of other improvements:

  • Schedule control now provides visual indication of current time through CurrentTimeMarkerVisibility property
  • CalendarView tabs visibility can now be controlled using TabStripVisibility property
  • Source code is now in Visual Studio 2010 format
  • Number of other bug fixes

Detailed release notes are also available.

DotNetBar for WPF 5.7 includes 18 controls that help you create professional WPF Applications with ease. You can download latest release from our Customer Only web site now.

As usual, we welcome your suggestions so feel free to contact me. Thank you for using DotNetBar everyone.


Today’s DotNetBar for WinForms update, contains improvements to Schedule control that many of you have been asking for. Now you can control time display in Day/Week view. Default view shows the working and non-working hours as specified on CalendarModel.WorkDays.WorkStartTime/WorkEndTime, i.e. you see 24 hours or whole day. Here is image that shows default view, notice that non-working hours have gray background:

But if you set CalendarView.ShowOnlyWorkDayHours=true you will see only working hours displayed on calendar. This image shows that, notice that non-working hours are not visible:

Images on appointments

Latest release also adds easy way to assign images to appointment. On each model Appointment object there are two properties you can use to do so:

  • Appointment.ImageKey – Specifies the key of the image in the ImageList that you assign to CalendarView.Images property.
  • Appointment.ImageAlign – Specifies the alignment of the image inside of appointment.

Here is screen-shot of two appointments with images assigned:

Yellow appointment has default image alignment, which is top-left, and blue appointment has bottom-right image alignment.

Release with these new features is available now.

Tagged with:

In my previous post on how to become really good developer, I touched upon something that I feel needs more attention. I said that you need to invest over 10,000 hours in practicing the craft to really become good. What I failed to mention is that those 10,000 hours must be progressively harder. You must push yourself out of your comfort zone and you must take on harder and harder assignments in order to really grow. Mindlessly doing something will not improve your skills. Doing things at the level you are comfortable at will not improve your skills. Like muscles that need to be exercised progressively harder to develop, mental skills require this increasing complexity to grow.

The biggest obstacle by far in this quest is temptation to give up, and you will be tested many times.  What you need to realize though is that quitting in long run is much harder than to keep on going. When you quit on yourself, you are chipping away your character. More times you quit, easier it becomes to quit. And that spreads like cancer to anything that you are trying to accomplish.

If you quit, guilt will follow with its cousins: could have, would have and should have. You start either beating yourself up for quitting or lying to yourself. You keep thinking that if you just have worked through difficulties, you would be on top of the world. You could have done it. You will look with envy at people that did. That’s why quitting is harder than doing it. This realization comes only after it is too late.

Don’t give up and quit on yourself.

Every game in life, whether it is programming, business or physical like sports, is always, always 90% mental game. “Whether you believe you can or can’t, you are right”, said Henry Ford. You quit in your thoughts and your attitude first, regardless of external circumstances. You model external circumstances in your head to support your decision no matter what circumstances are. You tell yourself that it is too hard, that it will take too long and that you just can’t do it. You put it off for next time. You withdraw mentally long before you manifest that outside.

Part of every big accomplishment is victory over these inner doubts and weaknesses. It is not that 10,000 hours of hard work is something you can’t do, anyone can, but it is hard to make yourself work at it every single day. That is hard. Forcing yourself to keep going when going gets though, when hour gets late and you’d rather watch TV than work.

So the biggest part, the most important part of becoming really good developer is persevering and not giving up when problems get too hard. Don’t ask for help from others on how to solve a problem. Solve it yourself first then ask for opinions on your solution. Volunteer for hard projects. If you see something that nobody wants to work on maybe it is something you should get done. Each problem you solve, each obstacle you work through, will add a brick to your character wall. Once that wall is standing tall and strong no problem will bring it down.

Just don’t give up!

PS. Please don’t get hang up on 10,000 hours. Depending on your profession and talent that number might be significantly higher, but rarely it is significantly lower. 10,000 hours should also not be used as excuse to start doing. Often we get side-tracked by “preparation” for the actual doing. This is just another form of procrastination. You can read as many books as you want about bicycle riding, but you can only learn to ride by actually doing it.


Today we released weekly update to DotNetBar for WinForms and Schedule control includes very nice new functionality that I would like to show to you.

The CalendarView control has the ability to display any number of TimeIndicators in the Day, Week, and TimeLine views.  TimeIndicators are used to give feedback to the user as to either the current system time, or a user designated time.  Here is an example of what a set of 3 different TimeIndicators could look like (click image for full size image):

DotNetBar Time Indicator in Calendar/Schedule Control

The CalendarView control has a default TimeIndicator object available for your configuration and use.  You can also define as many as you need and add them to the CalendarView.TimeIndicators collection.  Each TimeIndicator object has the following properties available for user configuration:

IndicatorTime: A DateTime value that signifies the root starting display time for the Indicator.

  • IndicatorTimeOffset: A TimeSpan value that signifies a time offset from the set IndicatorTime.  The Indicator will be displayed at IndicatorTime plus IndicatorTimeOffset.
  • IndicatorArea: The display area designation, as defined by eTimeIndicatorArea.
    • eTimeIndicatorArea.Header:  The Indicator is displayed only in the associated Time Header (green example in above figure).
    • eTimeIndicatorArea.Content:  The Indicator is displayed only in the view Content area (pink example in above figure).
    • eTimeIndicatorArea.All:  The Indicator is displayed in both the Time Header and view Content area (gold example in above figure).
  • IndicatorSource:  Designates the source of the IndicatorTime, as defined by eTimeIndicatorSource.
    • eTimeIndicatorSource.SystemTime:  IndicatorTime is updated by the System time at 1 minute intervals (if enabled, see below).
    • eTimeIndicatorSource.UserSpecified:  IndicatorTime is specified and maintained by the user.
  • Visibility:  Designates the Indicator’s visibility, as defined by eTimeIndicatorVisibility.
    • eTimeIndicatorVisibility.AllResources:  Indicator is displayed on all available views (gold example in above figure).
    • eTimeIndicatorVisibility.SelectedResources:  Indicator is displayed only on the currently selected view (pink example in above figure).
    • eTimeIndicatorVisibility.Hidden:  Indicator is hidden (default).
  • BorderColor:  Designates the leading edge border color.
  • IndicatorColor:  Designates the Gradient color of the Indicator.
  • Thickness:  Designates the thickness of the Indicator (default is 4).
  • Enabled:  Indicates whether automatic IndicatorTime updates are enabled (only utilized when IndicatorSource is SystemTime).

To utilize the default CalendarView TimeIndicator, you need only access it via CalendarView.TimeIndicator.  All you need do is to set the initial IndicatorTime and its Visibility to either AllResources or SelectedResources.

CalendarView.TimeIndicator.IndicatorTime =  DateTime.Now;
CalendarView.TimeIndicator.Visibility =  eTimeIndicatorVisibility.AllResources;

Here are code examples showing how to create the pink and green TimeIndicators as shown in the above figure:

TimeIndicator ti = new TimeIndicator();
ti.Thickness  = 10;
ti.IndicatorTimeOffset = new TimeSpan(2, 15, 0);
ti.BorderColor  = Color.Green;
ti.IndicatorColor = new ColorDef(new Color[] {  Color.Empty,
                    Color.GreenYellow, Color.Green },
                    new float[] { 0f, .5f, 1f  });
ti.Visibility = eTimeIndicatorVisibility.AllResource;
ti.IndicatorArea  = eTimeIndicatorArea.Header;
ti  = new TimeIndicator();
ti.Thickness = 20;
ti.IndicatorTimeOffset  = new TimeSpan(-2, 15, 0);
ti.BorderColor = Color.HotPink;
ti.IndicatorColor  = new ColorDef(Color.Empty, Color.Pink);
ti.Visibility =  eTimeIndicatorVisibility.SelectedResource;
ti.IndicatorArea =  eTimeIndicatorArea.Content;

TimeIndicators can be as subtle or as “daring” as you like:

DotNetBar Calendar/Schedule control time-marker, indicator custom appearance

The above was created with the following code:

ti = new TimeIndicator();
ti.Thickness = 40;
ti.BorderColor  = Color.MidnightBlue;
ti.IndicatorColor = new ColorDef(new Color[]
                    {  Color.Empty, Color.AliceBlue,
                    Color.DeepSkyBlue, Color.DarkSlateBlue },
                    new float[] { 0f, .15f, .55f, 1f });
ti.IndicatorArea =  eTimeIndicatorArea.Content;
ti.Visibility =  eTimeIndicatorVisibility.AllResources;

This covers the new time-marker functionality in our schedule control. Hope you find it useful. Stay tuned for more.

Tagged with:

Looking for something?

Use the form below to search the site:

Still not finding what you're looking for? Drop a comment on a post or contact us so we can take care of it!

Visit our friends!

A few highly recommended friends...

© 2009 Denis Basaric: DevComponents Blog