We're happy to announce that we're ready to release the new version 3.1.0 of SuperControls for Windows Forms. It includes many performance and feature improvements, several bug fixes, and additional example projects in C# and VB.NET.

The new version will be available for download on June 15th 2009.

We recently added a ribbon bar control to our components suite. One of the cool and unique features is that it supports Windows7 Scenic look and feel besides the standard Office2007 styles. You can change the style of the RibbonBar control by setting the RibbonStyle property.

You can find more about SuperRibbonBar at the Winforms Ribbon interface product page:

http://www.viblend.com/products/net/windows-forms/controls/ribbonbar.aspx
 

We're frequently asked about the easiest way to bind our data grid control to a data source. When you install VIBlend SuperControls the setup installs a folder with several fully functional demo projects in VB.NET and C#. You can learn a lot by browsing through this code base.

In any case here's a very simple data binding example where we create a List of objects and use it as a data source:

C# Example:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using VIBlend.SuperGrid;

namespace DataBindingDemo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            List<Employee> list = new List<Employee>();
            for (int i = 0; i < 100; i++)
                list.Add(new Employee("Name " + i, "Title " + i, "Phone " + i, "CellPhone " + i, "Address " + i));

            dataGrid.VIBlendTheme = VIBlend.Utilities.VIBLEND_THEME.OFFICEBLACK;

            dataGrid.BoundFields.Add(new BoundField("Employee Name", "Name"));
            dataGrid.BoundFields.Add(new BoundField("Employee Title", "Title"));
            dataGrid.BoundFields.Add(new BoundField("Employee Phone", "Phone"));
            dataGrid.BoundFields.Add(new BoundField("Employee Cell Phone", "CellPhone"));
            dataGrid.BoundFields.Add(new BoundField("Employee Address", "Address"));

            dataGrid.DataSource = list;
            dataGrid.DataBind();

            dataGrid.RowsHierarchy.AutoResize();
            dataGrid.ColumnsHierarchy.AutoResize();
            dataGrid.Refresh();
        }


    }

    class Employee
    {
        public Employee(string Name, string Title, string Phone, string CellPhone, string Address)
        {
            this.Name = Name;
            this.Title = Title;
            this.Phone = Phone;
            this.CellPhone = CellPhone;
            this.Address = Address;
        }

        #region Private Members
        private string _name;
        private string _title;
        private string _phone;
        private string _cellphone;
        private string _address;
        #endregion

        #region Properties
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public string Title
        {
            get { return _title; }
            set { _title = value; }
        }

        public string Phone
        {
            get { return _phone; }
            set { _phone = value; }
        }

        public string CellPhone
        {
            get { return _cellphone; }
            set { _cellphone = value; }
        }

        public string Address
        {
            get { return _address; }
            set { _address = value; }
        }

        #endregion
    }
}
 

VB.NET Example:

Imports System
Imports System.Collections.Generic
Imports System.ComponentModel
Imports System.Data
Imports System.Drawing
Imports System.Linq
Imports System.Text
Imports System.Windows.Forms
Imports VIBlend.SuperGrid

Namespace DataBindingDemo
    Partial Public Class Form1
        Inherits Form
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs)
            Dim list As New List(Of Employee)()
            For i As Integer = 0 To 99
                list.Add(New Employee("Name " & i, "Title " & i, "Phone " & i, "CellPhone " & i, "Address " & i))
            Next i

            dataGrid.VIBlendTheme = VIBlend.Utilities.VIBLEND_THEME.OFFICEBLACK

            dataGrid.BoundFields.Add(New BoundField("Employee Name", "Name"))
            dataGrid.BoundFields.Add(New BoundField("Employee Title", "Title"))
            dataGrid.BoundFields.Add(New BoundField("Employee Phone", "Phone"))
            dataGrid.BoundFields.Add(New BoundField("Employee Cell Phone", "CellPhone"))
            dataGrid.BoundFields.Add(New BoundField("Employee Address", "Address"))

            dataGrid.DataSource = list
            dataGrid.DataBind()

            dataGrid.RowsHierarchy.AutoResize()
            dataGrid.ColumnsHierarchy.AutoResize()
            dataGrid.Refresh()
        End Sub


    End Class

    Friend Class Employee
        Public Sub New(ByVal Name As String, ByVal Title As String, ByVal Phone As String, ByVal CellPhone As String, ByVal Address As String)
            Me.Name = Name
            Me.Title = Title
            Me.Phone = Phone
            Me.CellPhone = CellPhone
            Me.Address = Address
        End Sub

#Region "Private Members"
        Private _name As String
        Private _title As String
        Private _phone As String
        Private _cellphone As String
        Private _address As String
#End Region

#Region "Properties"
        Public Property Name() As String
            Get
                Return _name
            End Get
            Set(ByVal value As String)
                _name = value
            End Set
        End Property

        Public Property Title() As String
            Get
                Return _title
            End Get
            Set(ByVal value As String)
                _title = value
            End Set
        End Property

        Public Property Phone() As String
            Get
                Return _phone
            End Get
            Set(ByVal value As String)
                _phone = value
            End Set
        End Property

        Public Property CellPhone() As String
            Get
                Return _cellphone
            End Get
            Set(ByVal value As String)
                _cellphone = value
            End Set
        End Property

        Public Property Address() As String
            Get
                Return _address
            End Get
            Set(ByVal value As String)
                _address = value
            End Set
        End Property

#End Region
    End Class
End Namespace

Formatting the value of a grid cell is one of the most common tasks when working with data grids. Most spreadsheet applications, like Microsoft Excel, provide a built-in list with the most common cell formats. These include format expressions for numbers, currencies, dates, hours, and more. In addition, the user can easily create a custom cell format expression.
VIBlend SuperGridView, allows you to format the content a grid cell through a simple expression which follows the .NET string formatting rules. The value of a grid cell can be any object type, and it is up to you to specify how this value will be converted to text. Unless you associate the cell, or its column, with a format expression, the grid will try to get the text representation of the cell’s value by calling the ToString() method.
The code below formats all cells in the second column of the datagrid as dollar values with two digits behind the decimal point:

The installation package for VIBlend SuperControls for Windows Forms integrates all of the controls with the Visual Studio toolbox. It does that automatically at the end of the setup. This process works properly with Visual Studio 2005 and Visual Studio 2008 Standard, Professional and Team editions. However, due limitations in the Visual Studio Express editions, this process does not work with Visual C# Express and Visual Basic Express.

If you want to use VIBlend SuperControls for WinForms with Visual C# Express or Visual Basic Express, please follow these steps:

  1. Run the setup program and wait for it to complete the installation
  2. Open Visual C# Express (or Visual Basic Express)
  3. Create a new Windows Forms application
  4. Locate the controls toolbox and expand it
  5. Right click, and select ‘Add Tab’
  6. Type ‘VIBlend’ in the textbox
  7. Right click and select ‘Choose Items…’
  8. Select ‘Browse’ and location the installation folder for VIBlend SuperControls for Windows Forms
  9. Select ‘VIBlendSuperControls.dll’ and click ‘Open’
  10. Repeat the browse step again and select VIBlendSuperGrid.dll
  11. Click Ok

You should see all of the VIBlend controls inside the toolbox.

If you have any questions or problems with the installation process, please, email to: support@viblend.com

Windows Vista, Windows 2008 Server and the upcoming Windows 7 include enhanced security compared to earlier Windows versions. Those of you, who are using one of these operating system, know that you are often prompted to allow or block certain actions, which applications and installation programs try to do.

The installation package for VIBlend SuperControls for Windows Forms, requires permissions in order to register the library’s DLLs within the global assembly cache (GAC). It also needs permissions to integrate the controls with the Visual Studio's toolbox. In order to perform these actions, the setup has to be executed under elevated privileges.

Follow these steps to properly install VIBlend SuperControls for Windows Forms:

  1. Unzip setup.exe in an empty folder
  2. Right click on setup.exe
  3. Select 'Run as Administrator'
  4. Allow the setup to run under elevated privileges and follow the setup instructions

Again, this applies to you only if you are running Windows Vista, Windows 2008 server, or a later Windows OS with UAC (User Access Control).
If you have any questions or problems with the installation process, please, email to: support@viblend.com

In the new release of VIBlend SuperControls for WinForms you can find a new control which we called SuperNavPane.

SuperNavPane is a navigation type control which contains one more pane items (groups). A group in SuperNavPane is represented by a SuperNavPaneItem control. Each group has a build-in panel control where you can place any WinForms control. A SuperNavPaneItem can be easily customized using properties such as Image, ImageIndex, HeaderHeight, HeaderFont,  HeaderText. You can active a group by clicking on its header or programmatically through APIs.

SuperNavPane’s design-time support provides codeless experience  and allows you to build and customize the interface of you application in less time.
SuperNavPane comes with Office 2007 and Office 2003 themes, and additional themes which ship with SuperControls for WinForms. Smooth animations and carefully designed visual properties will give your applications vivid look and feel.

VIBlend SuperGridView ships with build-in data export providers for Microsoft Excel, XML, HTML and CSV.

The export functionality is accessible through the GridExport class inside VIBlend.SuperGridView.DataExport namespace.

Here's a a small example which demonstrates how easy it is to export the data grid's content:

VIBlend.SuperGrid.DataExport.GridExport gridExport = new VIBlend.SuperGrid.DataExport.GridExport();

gridExport.ExportToHTML(superGrid1, fileName); // export to HTML

gridExport.ExportToExcelXML(superGrid1, fileName); // export to MS Excel

gridExport.ExportToXML(superGrid1, fileName); // export to XML

gridExport.ExportToCSV(superGrid1, fileName); // export to CSV

The recently released version 1.4 of VIBlend SuperControls for Windows Forms includes several improvements and new features:

1. Build-in tooltips support in SuperGridView
2. Additional APIs to provide developers with extra flexibility and control
3. SuperGridView now allows you to specify text formatting, alignment, editors and other properties during data binding.
4. Visualization and theme improvements

However, the most important change is the re-designed rendering engine in SuperGridView which adds significant performance improvements. You can notice how fast our WinForms Grid is event if you don't work with too many rows or columns. We tested it with up to three million rows and it delivered absolutely excellent performance. Of course you will need a little bit of extra RAM if you need to make such experiments so we recommend you to use virtual mode. Please, don't forget to compare it with our competitors

With the release of version 1.3, there's no doubt that SuperGridView has the most robust and flexible conditional formatting capabilities when compared to other .NET grid controls on the market. It also looks cool as you can see from the screenshot below.

Here's the simple question: How hard is it implement this?

Well, SuperGridView makes it very very easy. Let's go through the process.

In order, to apply conditional formatting with color scales we must define a group of cells and associate with a specific color scale. This normally takes three easy steps.

Step 1. Enable Conditional Formatting and Create the Conditional Formatting group 

SuperGridView has a class which wraps this entire functionality. The class is defined within the DataFieldArea of the grid and it's name is ConditionalFormattingGroup. You can use it in the following way:

     grid.DataFieldArea.ConditionalFormattingEnabled = true;

     DataFieldArea.ConditionalFormattingGroup cfGroup = new DataFieldArea.ConditionalFormattingGroup();

     cfGroup.SetConditionalFormattingColorScale(GridCellCFColorScale.GREEN_TO_RED);

The SetConditionalFormattingColorScale method allows you to select one of the built-in color scales. If you prefer to create your own you can use the SetCustomConditionalFormattingColorScale method which simply takes an array of one hundered colors which define the scale.

Step 2. Add the group to the grid's DataFieldArea and assign in a name

This is just a single line of code which basically says: "Hey, SuperGridView, this is my ConditionalFormattingGroup and for you this is its name"

Step 3. Assign grid cells to the conditional formatting group

SuperGridView allows you to add individual cells to a group, as well as entire rows and columns. This is done by calling the methods SetCellConditionalFormattingGroup or SetItemConditionalFormattingGroup for individual cells and for columns/rows respectively.