The switch to using the KryptonMessageBox is very easy because you only need to perform a Find/Replace of the phrase MessageBox.Show with KryptonMessageBox.Show. This is because the exact same static Show methods have been used in the Krypton implementation as exist for the MessageBox which ensures an easy upgrade path. Check out the three new samples that can be accessed from the KryptonExplorer in order to see them working and experiment with the different settings that are possible.

Also present in this release is an important bug fix. Under Windows 7 the showing of a dialog that is derived from KryptonForm can fail. The bug is very nasty in that the dialog simply fails to be drawn on the screen, which is likely to be very confusing for your users. This has now been fixed. For a full list of changes you should check out the change lists that are installed.

New Components
- KryptonMessageBox
- KryptonTaskDialog
- KryptonInputBox

Download 4.3

Please download using the following direct link…

Download 4.2

Please download using the following direct link…

Download 4.1.5

Major Change
   – Moved all design time classes to separate assembly

New KryptonDataGridView Columns
   – KryptonDataGridViewComboBoxColumn
   – KryptonDataGridViewNumericUpDownColumn
   – KryptonDataGridViewDomainUpDownColumn
   – KryptonDataGridViewMaskedTextBoxColumn
   – KryptonDataGridViewDateTimePickerColumn

Major Bug fixes
   – TAB key works inside Navigator
   – AutoComplete works for KryptonComboBox
   – KryptonGallery memory usage improved

Download Kryton Beta

At the moment Krypton cannot be used in this situation because the Krypton design time classes are placed inside the same assembly as the relevant controls. So the Krypton Toolkit design time classes are inside the Toolkit assembly, Krypton Ribbon design time classes inside the Ribbon assembly and so forth. But the design time assembly is not included in the client profile and so the Krypton assemblies will not be loadable.

To enable this scenario I have now created a new ComponentFactory.Krypton.Design assembly and moved all the design time classes into it. This means you can write a client profile application that references the Krypton Toolkit/Ribbon/Navigator/Workspace/Docking assemblies and it will work just fine because the Krypton assemblies no longer reference the System.Design namespace.

Note that client profiles are a feature exposed in Visual Studio 2010 and so you will only be aware of them if you have downloaded and played with that version.

The single functional change is to the Office 2010 palettes. As the result of a developer poll indicated that people wanted the default size of the Office 2010 palettes changed to match that of the Office 2007 palettes. This change has been made in this release. You can however revert those palettes to the smaller size, or indeed any size you like, using the following example code…

   KryptonManager.PaletteOffice2010Blue.BaseFontSize = 8.5f;
   KryptonManager.PaletteOffice2010Silver.BaseFontSize = 8.5f;
   KryptonManager.PaletteOffice2010Black.BaseFontSize = 8.5f;

This new BaseFontSize property is available on the built-in palettes except the Professional variations. There is also a BaseFontName that allows the font to be changed away from the default Segoe UI setting.
 

Download Link
Download Krypton 4.1.1

Change Lists
Toolkit Change List
Ribbon Change List
Navigator Change List
Workspace Change List
Docking Change List

The extra functionality is a property that sets the base font size…

kryptonManager.PaletteOffice2010Blue.BaseFontSize = 9.5f;

This property is only provided on the built in palettes and can be accessed via the KryptonManager as seen in the above code example. This allows those that would like a bigger font for the Office 2010 palettes to achieve it using the above example code. Please report any issues inside the post comments or via a direct email to myself.

Download 4.1.1

New for Version 4.1
- Office 2010 Blue/Silver/Black Palettes
- Office 2010 Style Ribbon
- KryptonGroupBox
- Various bug fixes

Change Lists
- KryptonToolkitChangeList.doc
- KryptonNavigatorChangeList.doc
- KryptonWorkspaceChangeList.doc
- KryptonRibbonChangeList.doc
- KryptonDockingChangeList.doc

For those interested in the new Office 2010 palettes or maybe the new KryptonGroupBox control you can download the Beta of the upcoming 4.1 release from here…

Download Beta

New for Version 4.0
   – VS2010 Style Docking system
   – KryptonWrapLabel
   – KryptonSeparator
   – Workspace persistence
   – Workspace max/restore feature
   – Various bug fixes

Change Lists
  – Toolkit
  – Navigator
  – Workspace
  – Ribbon

Reduced Product Line-up
Something like 90% of all sales are for the full Krypton Suite and so I intend to simplify the list of product offerings by selling only the full Suite. Existing customers with the Navigator, Workspace or Ribbon that are still within their 12 month subscription will get a free upgrade to the Suite + Source. So no customers will miss out because of the change in policy.

The Suite will also only be offered with the full source code included so the ability to buy just a license is being removed. Most companies want the source code anyway and so this reduces the number of purchase options making it a simpler decision. So the purchase page is going to have just the Krypton Suite + Source with the only options being the number of licenses you want to buy.

BARGAIN ALERT: Yes, that means you could buy the Navigator at $149 before next Wednesday and get a free upgrade to the full Suite including the source code. Reading my blog means you get the inside track and your reward is a truly once in a lifetime bargain. Or why not get a 4 pack and save even more!

New Pricing
Currently the Suite + Source is priced at $399 (USD) and the new price with the docking system added will be $499 (USD). Looking at other comparable products on the market I still think this is a reasonable price given the extra flexibility and features it offers.

New Licence Options
Last is a change to provide customers with an upper limit on costs. I hope this will tempt more of the larger outfits to consider buying the Suite for the entire development department. I am introducing Site and Enterprise license options.

A Site license will allow an unlimited number of developers within your organization but limited to one geographic location. An Enterprise license allows for an unlimited number of developers at an unlimited number of locations for your organization. Customers with 16 or more licenses at the moment will be offered the chance to convert to either the Site or Enterprise depending on their licenses requirements.

The feature works with all the Navigator modes that display elements per-page. So any of the modes that have tabs, ribbon tabs or check buttons per-page can be reordered. Even the Outlook modes have the ability as they contain a set of check buttons at the bottom of the control.

I would show some screenshots but there is no effective way of showing it working. Just wait until the docking beta 2 in a couple of week’s time and then you can play with it.

To help me out I needed to add some new events, methods and properties to the workspace and navigator controls. I thought you might find some of these handy for y0ur own applications so here is a quick summary…

KryptonWorkspace
   Methods
      HideAllPages()
      ShowAllPages()
      FirstVisibleCell()
      NextVisibleCell(…)
      PreviousVisibleCell(…)
      LastVisibleCell()
      IsCellPresent(…)
      PageForUniqueName(…)
      CellForUniqueName(…)
   Properties
      CellVisibleCount
   Events
      CellCountChanged
      CellVisibleCountChanged

KryptonNavigator
   Methods
      HideAllPages()
      ShowAllPages()
   Properties
      AllowTabSelect
      Bar.BarLastItemInset
   Events
      TabCountChanged
      TabVisibleCountChanged
      TabMouseHoverStart
      TabMouseHoverEnd

Right clicking on the Workstation tab header shows a context menu with a new Maximize option.

Selecting the option gives the following maximized layout with all but the maximized cell hidden from view.

Right click the tab header again and you will find the Maximize option has changed to become Restore instead. Keyboard users can use the shortcut Ctrl + Shift + M combination to toggle between maximized and restored.

In the examples above you can see a ButtonSpec that I added with appropriate images that allows an easier method of switching without requiring the user to discover the feature by looking at the context menu. This ButtonSpec is not added by the workspace and so if you want the same ability you will need to add it manually just as I did. You can see the new Cell Maximize + Restore sample to discover the few lines of code needed to add this capability.

Double Clicking Tabs
I’ve also added a new event to the KryptonNavigator called TabDoubleClicked which is fired whenever the user double clicks with the left mouse button on the tab header. In my new sample this is used to toggle the maximzed state but you could use this as a trigger for any default action you would like to perform.

Persistence Formats
Use SaveLayoutToFile and LoadLayoutFromFile in order to persist to/from a file. The actual contents of the file will be an XML document but you can ignore this as modifying the contents risks making it invalid. Alternatively use the SaveLayoutToArray and LoadLayoutFromArray methods to deal with arrays of bytes. An array of bytes makes it easy to save the data into a database and so associate the layout with user’s details. Or you could convert the array of bytes into a Base64 string and include it into your own applications persistence mechanism.

There are two other formats for those needing even more options. SaveLayoutToXml and LoadLayoutFromXml use references to instances of XmlTextWriter and XmlTextReader classes respectively. So if you are already using these two classes for streaming your own data you can call into these methods and have the layout data inserted into your own XML data. Finally th SaveLayoutToStream and LoadLayoutFromStream are the most flexible and allow you to supply any Stream derived class.

Persisted Information
The hierarchy of the layout is saved starting with the Root sequence of the control. Each workspace sequence and cell is saved along with the details needed to recreate that item. Each cell can contain any number of individual KryptonPage instances, so details about each page are also saved including most, but not all, of the properties of the page. You should assume that everything about the page is saved except for two types of information. The actual set of child controls that exist on the page are not persisted and neither are the modified values of the State properties. We can see the implications of this by looking at the two likely scenarios for usage.

In the static scenario the set of pages in the workspace are going to be fixed and so every time you run your application the pages are identical. This is the easiest situation to handle.  Reloading is only expected to result in the repositioning of pages into a new layout but not cause the creation or removal of pages. You do not need to write any additional code to handle this scenario and simply calling the Save/Load methods will perform this default behavior. This is because when a page is loaded the control attempts to lookup the named page in the existing set of pages. If found it simply uses that existing page. In this static scenario the loading page will always be found and so reused.

In a dynamic scenario the set of pages could be different every time the application is run. Here you would be creating new pages depending on the users actions. Now when you load a layout you are likely to find that none of the existing pages match those being loaded. When a loading page does not match any of the existing ones then it creates a new page instance and updates the page with the loading data. Once the loading is complete it will remove any pages that are no longer required. This scenario does require you to write some additional code because the child controls on a page need to be created by the developer and are not persisted by the workspace control. Hook into the PageLoading event which is called each time a page is loaded and add the child controls as appropriate for that page (more on this below).

Customization Events
It is very likely you will want to save some additional application specific information along with the automatically generated content. To allow this use the GlobalSaving and GlobalLoading events to persist whatever arbitrary data you like. Use the PageLoading and PageSaving to persist custom data on a per-page basis.

As noted above, the PageLoading is the event used to not just recover custom data but also allow you to modify the page instance before it is used. If you have pages being created then this is where you would add the appropriate child controls and perform whatever data binding etc might be required. You can go even futher than that and assign a new page instance to the returned event data so that your assigned page is used in place of the original. It will probably be easier to create a new page in your event handler than try to customize the page provided by adding the child controls in code. Note you could assign null to the returned event data and so prevent a page being added at all. This is the technique needed to prevent a loading page from being added to the workspace, effectively ensuring the loading page is ignored as no longer required.

Our final event is fired at the end of the loading process and called PagesUnmatched. This event provides you with a list of pages that were present before the load started but were not matched with any loaded page. By default, if you do nothing then those unmatched pages will be deleted from the workspace. Hook this event if you need to examine that list of unmatched pages and instead use code to add them into the workspace again so they are not removed.

I have added a new workspace demo that shows per-page custom data being added to the persisted information so that you can see in code how easy it is.

This new beta has quite a few changes based on the feedback from testers of the first version earlier in the week. Most of the changes are in the date time picker and month calendar controls. Here is a full list of changes since the first beta…

KryptonDateTimePicker

• Text property now returns the actual displayed text, used to always return an empty string.
• MouseWheel now performs the key up/down action of the active text field.
• Entering 31 for the day number would not select the correct day.
• Up/Down actions on the day would not overflow within the same month.
• Mouse down on non-day parts of calendar would dismiss the context menu.

KryptonMonthCalendar

• Drawing was corrupted for many non-English culture settings.
• Can now set the background to transparent so parent background shows through.
• Changing the DayStyle could crash when using a KryptonPalette.
• When number of rows and columns were different mouse selection could crash.
• Can now enter 1 or 2 digits for the descriptive month field to change the value.

Other

• Palette upgrade tool now converts versions 12 and below to latest version 13.
• Switching Navigator between Outlook modes would cause a crash.
• KryptonComboBox would select text when you minimize/restore the form.

Download Beta 2

KryptonDateTimePicker
KryptonMonthCalendar
DateTimePicker for KryptonRibbon
MonthCalendar for KryptonContextMenu
Per-KryptonPage ButtonSpecs
Many bug fixes (consult change lists)

I will create a forum so that bugs and other feedback can be logged for the beta specific release.

Download Beta

Creating the hierarchy of bread crumb items at design is very painful at the moment. You need to edit each set of child items as a flat list of items. So if you need to edit a node several levels down the structure you end up with several collection editors all open at the same time, one for each level of the structure as you make your way down to the node of interest. Not pretty.

I have now implemented a collection editor that presents all the items in a tree view so that you can see all the nodes at once and easily move them around as needed. Here you can see it in action…

KryptonWorkspace

The same problem applies to the recently introduced KryptonWorkspace control. It consists of a tree like hierarchy of elements that would benefit from a user friendly editor. In fact it needs the editor more than the bread crumb control because it is much harder to visualize the structure with the workspace. Here is the new improved editing dialog…

Download Link for 3.0.6

Major Bug Fixes
- Locking/Unlocking computer causes text to disappear.
- Text not drawing at all for some Visual Studio projects.
- ComboBox drop down not working on some computers.
- Cannot edit Image properties with KryptonContextMenu.
- Design time change of Ribbon.MinimizedMode crashes.
- Removing all Ribbon tabs still draws last tab shown.

Feature Changes
- KryptonDomainUpDown added to the Toolkit.
- KryptonBreadCrumb now has overflow button feature.

If you have a valid subscription to one of the commercial products the you should already have received an email notification with download details. You do not need new serial keys, existing 3.0 keys will work just fine. Also remember to uninstall your current version before installing the new one.

Just a quick update to show a couple of pictures with a new indicator style. If you are using Visual Studio 2008 under Vista then you will have noticed that the docking indicators are not square anymore. Under Vista it uses rounded indicators so of course we need to provide that style as well. Here we have the mouse hovering over the cell top edge indicator…

And over the middle indicator…

Intelligent Defaults

All of the built in palettes test for the operating system in order to decide on the appropriate feedback. So on Vista you get rounded and on earlier systems you get the square view as seen in the previous post. It also tests to ensure that your display has more than 8 bits per pixel color.

This is important because when running over remote desktop or terminal services the bandwidth is kept down by using only 256 colors per-pixel. In that case you cannot use the WS_EX_LAYERED setting that is required for the rounded appearance. In order to get a smooth rounded edge you need per-pixel alpha capabilities and so you must use a layered window. With only 256 colors per-pixel your not going to get proper alpha blending and so it is best to fall back to using the docking squares.

Instead of using solid blocks to represent drag/drop feedback we now have full docking style indicators. Here you can see the mouse over the right control edge indicator. When the mouse is over the indicator it shows a solid blue rectangle indicating where the drop will occur.

Cell Indicators

As you move the mouse over a workspace cell it displays the possible drop options. Here we have the mouse over the center indicator that shows that dropping will cause the page to be transferred into the cell itself.

Notice that when we hover over the original cell it does not show any center indicator. This is because it makes no sense to drop the page back on the cell it is coming from.

One unique feature of the KryptonWorkspace control is the hierarchical structure to the layout definition. It means you can easily and quickly create complex layouts for your document area. But this strength is also a potential weakness because moving pages around could cause the structure to become inefficient and leave redundant entries.

To prevent this happening there are some flags that indicate how to perform a compacting phase just before the layout of the contents occurs. Each of the compact flags is used to resolve a potential problem. The flags are exposed as the CompactFlags property of the KryptonWorkspace.

CompactFlags.RemoveEmptyCells

Using drag and drop you can transfer a page from one to cell to another. If you remove the last page in the cell you are left with a cell that has no pages. Some applications may want this to happen but many others would prefer the cell be automatically removed as an empty cell is redundant. When this flag is set the compacting phase will search for any cells that have no pages defined and remove them from the hierarchy.

CompactFlags.RemoveEmptySequences

Removing empty cells can result in a workspace sequence existing that has no contents. Once all the cells contained in the sequence have been removed we are left with a redundant sequence. The user will not see the sequence as it is likely to be zero sized but it still exists in the hierarchy. During compacting this flag will search for sequences that have no children and automatically remove them.

CompactFlags.PromoteLeafs

A more subtle scenario involves a sequence that contains just a single child. If a sequence contains just a single child item then that sequence itself is redundant as it only encloses one item. This flag will promote the single child into the place of the sequence and delete the no longer needed sequence.

This situation occurs if you used drag and drop to move pages around. You can end up with a sequence that contains a single sequence child that contains yet another single sequence child and so forth. Although you would not see any visual impact it is clearly inefficient to have long chains of single sequences.

CompactFlags.AtLeastOneVisibleCell

Last but by no means least is a flag that ensures we always have at least one visible cell in the workspace. If the user deletes the last showing page in the last showing cell then the RemoveEmptyCells flag above would remove that last cell and leave the workspace area blank. Some applications require that there is always at least one cell showing even if it has no pages in it. This flag will ensure that is the case.

Layout and Compacting

By default all the above compact flags are set and this ensures that the child hierarchy is always small and efficient. Compacting occurs at the start of control layout activity and so you do not need to worry that it wil be applied whilst you are programmatically changing the structure.  So you can make many changes and the compacting will not interfere until the OnLayout is processed. If you are worried then simply wrap your changes inside the SuspendLayout/ResumeLayout pair of commands.

The previous post showed that you can drag pages around the KryptonWorkspace control in order to change the layout of the workspace area. We now need to extend this another level because in the real world you may want to drag pages between different control instances. As the KryptonNavigator also deals with KryptonPage instances it makes sense to allow pages to be dragged to and from Navigator as well as Workspace controls.

Drag Navigator to Workspace

The following images show a Form that has two KryptonNavigator instances at the top and a single KryptonWorkspace control at the bottom. We start by selecting page P1 from the top left Navigator…

And then drag it over to right side of the Workspace…

Dropping creates a new cell inside the Workspace with the page transferred.

Drag Workspace to Navigator

Moving in the opposite direction is just as easy. Just start dragging P1 from the Workspace and move it over the client area of the Navigator instance…

Notice that the Navigator gives feedback by showing the light blue area over the entire Navigator instance. There is only one thing the Navigator can do with a page drop and that is adding it to the end of its existing set of pages. So the only feedback, no matter where you move the mouse, is to show the entire control as the feedback area. Once you drop the page you get the following result…

Drag Navigator to Navigator
Drag Workspace to Workspace

You can ignore the Workspace entirely and just transfer pages from one Navigator instance to the other. Just drag P1 and move the mouse over to the other Navigator like so…

So you have the flexibility of dragging pages from/to Navigator /Workspace instances. This is not happening by using the traditional drag and drop mechanism provided in Windows. Starting the drag operation is not using the DoDragDrop call that you might be familiar with. Instead I have created my own class that manages the process.

Targets/Notify/Manager

You need three things to perform drag and drop. First you need a set of potential targerts that can accept the drop and for that we have the IDragTargetProvider interface. Second we need to allow drag operations to be started and we have the IDragPageNotify interface for that. Finally we need an instance that manages the orchestration and so there is a class called DragManager.

IDragTargetProvider

In practice this means that the Navigator and Workspace both implement the IDragTargetProvider interface
because both are capable of being drop targets for page dragging. This public interface could be implemented by any control so you could certainly make your own controls drop targets. The samples for the next release will give a couple of examples showing how to make a simple Button control or TreeView a drop target.

IDragPageNotify

The Navigator and Workspace also expose a property called DragPageNotify that stores an instance of the IDragPageNotify interface. Whenever you start a drag operation it callw back on this provided interface with the relevant mouse events. DragManager implements this interface and so can be passed into the DragPageNotify property of any control that wants to be able to start a drag. Again, the samples will show how to implement this on a Button and TreeView.

So the real story of this post is not that you can easily drag and drop pages between Navigator and Workspace instances, but you can easily integrate your own controls into this dragging mechanism. The above three controls are linked together using the following simple code…

DragManager dm = new DragManager();  

// Add drop targets
dm.DragTargetProviders.Add(kryptonNavigator1);
dm.DragTargetProviders.Add(kryptonNavigator2);
dm.DragTargetProviders.Add(kryptonWorkspace1); 

// Add drag sources
kryptonNavigator1.DragPageNotify = dm;
kryptonNavigator2.DragPageNotify = dm;
kryptonWorkspace1.DragPageNotify = dm;
 

The KryptonWorkspace has been conceived to provide two major features that make it stand out from any other control available. First up is the ability to layout the child Navigator instances in a hierarchical manner with accurate control sizing. A previous post about star sizing has already described this ability in some detail. Second is the capacity to drag and drop the pages within the workspace to change the organization.

Drag to Control Edges

When you drag a page you have several options about where to drop the page. Your first choice is to drop at one of the four edges of the workspace in order to create a new cell. Here we have a series of three images showing this happening…

The second image showed the light blue overlay that indicates the mouse is over an area that is valid as a drop target. Each of the four control edges has such a hot zone allowing you to drop and create a new cell at that particular edge.

Drag to Cell Edges

Each cell also exposes hot spots on the four inner edges of itself. This will then create a new cell at the position indicated by the light blue indicator overlay. These pictures show a page being dragging to the bottom edge of an existing cell…

Drag to Transfer

Finally you have the option of moving a page from one cell to another without creating a new cell at all. This simple transfer operation can be seen below…

How do you specify the size of a KryptonWorkspace cell? It sounds trivial and the automatic answer would be to use a pixel value but this alone does not actually work. If you set a constant value then it implies you want the size to be fixed. Maybe some of your cells should be fixed in size and so specifying the pixel value is adequate but what about other cells that change in size according to the space available?

The simplest example is an instance of the Workspace that has a single cell. With a single cell you would expect it to occupy the entire area no matter how the user resizes the control. If you specify the size in pixels then you automatically fail. Instead I have copied the star sizing technique that is used by the grid control in WPF.

Star sizing

Star sizing allows you to add an asterisk to the end of the size value if you want the size to be proportional to the remaining space available. Here we have two cells that each have a width defined as ’1*’.

The available width is first allocated to whatever fixed size cells are defined. We have none and so the entire width is then allocated to the cells with stars defined. The total number of stars is 2 and so each cell gets half the available width as they each have half the number of total stars. As we expand the window we get the following change in appearance…

Both still get half the total width. We now update the first cell to have a value of ’3*’ and see what happens…

The total number of stars is 4 and so the first is given 3/4 of the space and the second cell 1/4 of the space. Using stars makes it very easy for you to indicate the relative proportions of each cell. These examples only show the width changing but the height works in the same way for sequences that are arranged in the vertical direction.

Fixed and Proportional

Most real world scenarios will likely include fixed as well as proportional cells. To show this we define three cells with widths of ’100′, ’1*’ and ’1*’ respectively. This is how it looks…

The first cell is fixed in width and so allocated the full 100 pixels with the remaining space split evenly between the other two cells. If we expand the window we get the following…

As expected the first cell stays the same and the others split up the larger space between themselves. Now let’s change the last cells width to be ’4*’ and see the change…

Our last cells is taking up 4/5 of the remainder and the second cell just 1/5. Shrinking the window changes the appearance like this…

The combination of fixed and proportional sizing gives the flexibility you need to construct just about any scenario you are likely to need. When you use the splitter to change the sizing it will automatically update the star and fixed sizes correctly. Calling the size fixed only refers to a fixed layout and does not mean the users cannot change the size using the splitter.

Minimum and Maximum

Each cell has the standard control properties of MinimumSize and MaximumSize. These properties are correctly honored when laying out cells and deciding how much space to allocate. So if you specify a maximum width of 200 pixels for a cell that is using star sizing it will enforce that setting. As your window gets bigger each star cell gets bigger and bigger except that particular cell which will stop growing at the 200 pixel mark leaving the other star cells to grow instead.

Krypton Workspace

I have just started on a completely new component called Krypton Workspace. If you’ve been following the blog and forums you will know that my intention is to add a docking system to the Krypton suite of components. But in order to add docking windows I need the Workspace component.

This component will be the building block that is used inside the client area of floating windows as well as docked windows at the edge of a Form. Rather than reserve the control for exclusive use inside the docking windows it will also be available as a standalone control. I imagine it will be invaluable as the filler that appears as the main Form content. Think of it as the Visual Studio document editing area but with a little added Kryptonite!

KryptonWorkspaceCell

The KryptonWorkspace has a property called Children that represents the root collection of items for display. Each KryptonWorkspaceCell instance you place inside this will appear as a Navigator instance in the client area of the control. In fact the KryptonWorkspaceCell class is derived from KryptonNavigator. Here you can see the effect of adding three cell instances, one at a time…

 
KryptonWorkspaceSequence

The Children collection is an instance of the KryptonWorkspaceSequence class and allows any number of child elements to be added. By default the sequence direction for layout is horizontal but you can easily switch this to vertical by updating the Orientation property. Unlike Visual Studio you are not restricted to having entries in a single direction. You can place sequence instances inside another sequence. This allows any depth of hierarchy to be created…

The structure used to create this arrangement is very simple…

KryptonWorkspace.Children
...KryptonWorkspaceCell      (1,2)
...KryptonWorkspaceSequence  (Vertical)
......KryptonWorkspaceCell      (T,Y)
......KryptonWorkspaceCell      (Horizontal)
.........KryptonWorkspaceCell      (Q,W)
.........KryptonWorkspaceCell      (E,R)
......KryptonWorkspaceCell      (U, I)

As each individual cell is really just a Navigator, with some extra properties; you can alter each cell with the full flexibility of the Navigator. You could change its mode so it looks like a simple panel or have the full Outlook functionality. 

All of the above examples have used the default sizing which is to give each item an equal amount of the available space. So as you make the window bigger all the cells get bigger as well. My next task is to add more control over the sizing so that you can actually use it in real world scenarios.