Tab Controls And Splitters - Adding Some Dockable And Floating Sugar

• Download demo project - 185 Kb
• Download source - 35.8 Kb
• The latest version of the code

Introduction

In the previous article, I introduced SplitPane class that manages client view windows with splitters and tab panes and provides an interaction interface with the owner class. In this article, I would like to represent Frame class that extends SplitPane functionality with dockable and floating features. Also, I am going to consider that you know what dockable and floating windows are. Sure, the best example of those is Visual Studio .NET IDE. I guess you are also aware of an excellent job that has been done by Sergey Klimov and the further improvement by Daniel Bowen. This article is just an attempt to provide a simpler interface for the particular case, with a little bit different paradigm. I hope I have succeeded in it.

What it does

Briefly: Frame class provides dockable and floating environment for client views. There are three parts to this environment, the main pane, dock panes and float frames. All of them are owners of SplitPane, so you can split and tab all client views. Also, the client views are separated in two different groups, dockable views and document views. The difference is simple. The dockable views cannot be attached in the main pane but can be docked in one of the docked sides. The document views are unlike them, they can be attached in the main pane but cannot be docked. Both of them are able to become floating. That's the difference with Visual Studio .NET IDE. To prevent a floating window to get docked to any place, keep CTRL key pressed while dragging it.

Using the code

The use of Frame class can be as simple as the use of SplitPane class. It's also designed for SDI applications. I won't repeat all steps but a few points. With all include files mentioned in that, you will want to use DockTabFrame.h with the Frame class implementation. This is also in DockSplitTab namespace. There is a ClientView class that has all necessary properties for the client view windows. Frame class provides a communication interface for the interface with the owner or parent class. This is the FrameListener abstract class. clientDetached is the only function provided for this interface so far. Frame class calls it when a user closes a dock pane, a float frame or a tab. In other words, when he pushes a close button. There is a detachClientView function for Frame class that does the similar action but does not raise clientDetached event. Frame sends WM_CONTEXTMENU Windows message to the client views in appropriate cases. For instance, when you click a right mouse button on the tab.

Frame class

Public methods:

// creates a new Split Pane window with parentWnd and rect parameters

HWND create( parentWnd, rect);

// sets the keyboard focus to the specified client view window

bool setFocusTo( clientViewWnd) {

// retrieves the client view window that receives the keyboard focus

HWND focusedClientView();

// toggles client view state and move

// the client view to an appropriate pane

bool toggleClientViewState( clientViewWnd, ClientView::State);

// retrieves client view properties with client view window handle

ClientView* getClientView( clientViewWnd);

// adds a new client view

bool addClientView( clientView);

// adds a new client view and attach it to the specified dock pane

bool dockClientView( dockSide, clientView);

// shows/hides the specified dock pane

bool showDockPane( dockSide, show);

// retrieves the visibility state of the specified dock pane

bool dockPaneVisible( dockSide);

// retrieves the existence state of the specified dock pane

bool dockPaneExists( dockSide);

// float frame iterator functions

POSITION floatFrameStart()
HWND floatFrameNext( &position);

// adds a new client view and attach it to a new float frame

// with the specified location

HWND floatClientView( rect, clientView);

// retrieves the visibility state of the specified float frame

bool showFloatFrame( floatFrameWnd, show);

// check if a float frame is visible

bool floatFrameVisible( floatFrameWnd)

// check if a float frame exists

bool checkFloatFrame( floatFrameWnd);

// reattach the client view. the function uses

// the last location object propertes

void attachClientView( clientView);

// detaches the client view window 

// This method changes the parent window of the client

// view window to the Frame's parent.

ClientView* detachClientView( clientViewWnd);

// retrieves the visibility state of the specified client view window handle

bool clientViewVisible( clientViewWnd);

// checks if client view window is attached.

bool clientViewAttached( clientViewWnd);

// set and get Image List

void setImageList( imgList);
HIMAGELIST getImageList();

Inside of Frame class

There are implementations of two very important classes for Frame class. These are DockPane class and FloatFrame class. Each of them has its own SplitPane member. So you can split and tab client views inside of each DockPane or FloatFrame instance. Frame class itself also owns SplitPane instance. An objective of this instance is to keep document views. Frame class communicates with the float frames, dock panes and main pane via FloatDockFrameListener interface class that extends CallBackListener interface.

What's the next

Two things are left to do: Serialization and Auto hide panes.

References

• Cool Tab controls by Bjarke Viksoe
• Custom Tab Controls, Tabbed Frame and Tabbed MDI by Daniel Bowen
• WTL Docking windows by Sergey Klimov
• Always fresh meat