A Splitter Window Control

This article contains updated code for the splitter
window control created by myself several months ago. Also I provide here some
descriptions where and how to use such control. I must admit that the previous
version of the control was rather unreliable and it failed to work correctly in
many cases. This version is much more stable, although I can’t guarantee
that it will work in all conditions you want. In this article I do not try to
show the difference of code between this and the previous version of the
control. I just describe it from the scratch.

After the publication of the first version of the
control I received some messages, which told me that some people had not
understood the idea of this component. I was asked questions like:

I have a dialog box derived class in an MFC project. The
class has two members: m_TreeCtrl and m_ListCtrl created with help of the MFC
Class Wizard. The question is how to put the members into the splitter window
control?

Here is my answer. The control I have created is
supposed to be used in other tasks. Actually, to create a splitter window
control to be used in an MFC dialog box is a much easier task (if not take into
account the ability to place ActiveX controls into panes). You can even use
portions of code from my control. You do not have to deal with COM. All you have
to do is to provide a way of letting know the splitter control the window
handles of other controls on the dialog you want to place in panes. When the
user changes the sizes of panes you would call SetWindowPos function.

The control is being described in this article is
supposed to be used in ActiveX control containers such as forms in Visual Basic.
Personally myself I am going to use the control in ActiveX scripting hosts with
forms support. An example if such program is provided as a testing program. The
task of the control is to manipulate other ActiveX controls, placed on the same
container, to be used as panes.

In the Results\Release folder you will find a lot of files. One
of them is “SplitterWindowControl.ocx “ one. Register it.

In the same folder you can also find a testing program
– ATnT. This program
is an example of an ActiveX scripting host created
with help of the HyperHost
library provided by Dundas Software company, plus
one of my own libraries.  In

fact, ATnT is loosely based on
HyperHost’s ATnTLite sample.

To test splitter control with the ATnT program, run the
program first. Invoke the File | Open menu item. Select ATnT.mdb file and press
[Open] button. You will see “Main Form”, on the first page of which
there will be two splitter controls. The first splitter control has a list view
in its left pane and another splitter control in its right pane. The second
splitter control manipulates two other list view controls.

You can also try to open “Splitters.afm”
file with the ATnT program. The form in this file demonstrates two splitter
controls, placed on different pages. You can also notice that the program can
open module files (scripts to control the “Application” object
exposed by the program), plus files of ActiveX document servers registered on
your computer. At the end of the article there is a chapter, which describes
what the ATnT sample is, what it demonstrates and how to obtain its source
code.

I hope you know everything about CSplitterWnd class. I
will not explain here what it is. This is MFC code guru site is not it? He, who
does not know, can always learn it from the documentation. This control has a
splitter window. The splitter window in this control always consists of two
panes (if you improve it to use more and send me your updates I would appreciate
that). The splitter window can have two rows or two columns. The control has 4
properties. It fires no events and has no methods.

Properties:

[id(1)] BSTR strFirstControlName;

[id(2)] BSTR strSecondControlName;

[id(3)] boolean bVertical;

[id(4)] short intFirstPaneSize;

[id(5)] long _pointer;

The strFirstControlName property tells the control the
name of other control to put into the first pane. The strSecondControlName
property tells the control the name of other control to put into the second
pane. If bVertical is TRUE, then we have a splitter with two columns, if it is
FALSE, we have a splitter with two rows. The intFirstPaneSize property contains
width or height of the first pane, depending on the value of the bVertical
property. The pointer property is a read only property, which contains the
pointer to this control. Here is how the pointer is returned:

You can place the control on a form. Then place another
two controls to use in panes (see the picture bellow).

Notice that you do not have to align your controls with
the panes. But I do recommend you to put them above the panes. You can not use
windowless controls as panes.

Having put the controls on the form, you must attach
them to the splitter window control. You can do this manually by assigning their
names to the “strFirstControlName” and
“strSecondControlName” properties respectively, or by invoking the
property page for the control.

You can pick the control you need from the comboboxes.

When you switch your form into the user mode the
attached controls will be placed into panes. Do not forget to turn off the
border from the controls your are going to attach to the splitter control. This
will make the picture better.

The idea is a simple one.

1. We place a splitter window on our control.
   
2. Provide an ability to find other controls on the
   form.
   
3. When the control container is in the user mode we
   access the “pane” controls by their extended “Name”
   properties and change their position when user changes sizes of panes.

The CSplitterWnd class is very capricious. It was
designed to be used in frames, and to use CView derived classes as panes. To
save my time I had to satisfy it with these conditions. The
RecreateSplitterWindow demonstrates the sequence of code to create the splitter
window. As you can see the control uses a CFrameWnd derived object to cover all
the control’s client area. The splitter window is placed into the frame
one. Two CView derived objects are placed into panes. The view objects do not
have documents. The frame window and the view ones were created just to satisfy
MFC version of the CSplitterWnd class.

Here is the list of window classes participating in the
implementation of the control:

1. CSplitterWindowControlCtrl – is a COleControl
   derived class, which represents the ActiveX splitter control.
   
2. CSplitterControlFrame – is a CFrameWnd
   derived class, instance of which is placed on the
   CSplitterWindowControlCtrl’s one.
   
3. CControlsSplitterWnd – is a CSplitterWnd
   derived class. An instance of this class is placed in the client area of the
   CSplitterControlFrame.
   
4. CSplitterControlView – this class provides
   views for the splitter window.

Now we will learn how to find other controls, placed on
the same form along with our control. We will ask the form to provide us with
this information and store it in a CControlInfoArray.

The CControlInfo structure stores the extended name
property of a control (the one, which is given to the control by the container)
and the IOleObject interface of the control. The GetOtherControlsOnTheContainer
function fills a CControlInfoArray with the information about controls.
Let’s see how does the thing work.

1. When a container places an object onto itself, it
   gives the one different site interfaces, through which the object can
   communicate with the container. In our case IOleClientSite is used. There
   are other interfaces IOleControlSite, IOleControlSiteWindowless,
   IBoundObjectSite etc.
   
2. Any good container implements IOleContainer
   interface, through which we can get IUnknown pointers to the objects the
   container contains.
   
3. If the container provides extended properties and
   events it does it by adding an “extender” COM object, which
   aggregates the control. The IDispatch interface to the
   “extender” object is provided through, the corresponding to the
   object, site interface.
   
4. It seems to be a standard that containers
   distinguish the controls by the unique strings they associate with each
   control. The string is accessible through the “Name” extended
   property. Using the IDispatch of the “extender” object we can
   obtain values of the extended properties.

void
CControlsSplitterWnd::RecalcLayout()

{

CSplitterWnd::RecalcLayout();

GetParentActiveXControl()->DelayControlsReposition();

}

void
CControlsSplitterWnd::AdjustControlsToPanes()

{

CSplitterWindowControlCtrl* pControl=
GetParentActiveXControl();

pControl->m_intFirstPaneSize=pControl->GetFirstPaneSize();

if(!pControl->AmbientUserMode())

return;

 

CControlInfoArray arrayControls;

pControl->GetOtherControlsOnTheContainer(arrayControls);

 

CWnd* pWndPane1=GetPane(0,0);

CWnd* pWndPane2=NULL;

if(pControl->m_bVertical)

pWndPane2=GetPane(0,1);

else

pWndPane2=GetPane(1,0);

 

if(!pWndPane1 || !pWndPane2)

return;

 

PlaceControlOnPane(pControl->m_strFirstControlName,pWndPane1,arrayControls);

PlaceControlOnPane(pControl->m_strSecondControlName,

pWndPane2,

arrayControls);

}

void
CControlsSplitterWnd::PlaceControlOnPane(LPCTSTR lpstrControlName,

CWnd* pWndPane,

CControlInfoArray&
arrayControls)

{

int nPos=arrayControls.IndexOf(lpstrControlName);

if(nPos!=-1)

{

IOleInPlaceObjectPtr pOleInPlaceObject;

IOleObjectPtr
pOleObject=arrayControls[nPos].m_pOleObject;

pOleObject->QueryInterface(IID_IOleInPlaceObject,

(void**)&pOleInPlaceObject);

 

if(pOleInPlaceObject)

{

HWND hwndControl=NULL;

pOleInPlaceObject->GetWindow(&hwndControl);

if(::IsWindow(hwndControl))

{

CRect rectClient;

pWndPane->GetClientRect(rectClient);

 

//Convert coordinates to the
container’s ones

CRect rectObject(rectClient);

pWndPane->ClientToScreen(rectObject);

IOleClientSitePtr pClientSite;

pOleObject->GetClientSite(&pClientSite);

 

CWnd wndContainer;

wndContainer.m_hWnd=GetContainerWindow(pClientSite);

 

wndContainer.ScreenToClient(rectObject);

wndContainer.m_hWnd=NULL;

 

CSize size;

pOleObject->SetExtent(DVASPECT_CONTENT,&size);

pOleInPlaceObject->SetObjectRects(rectObject,rectObject);

size=rectObject.Size();

CClientDC dc(this);

dc.DPtoHIMETRIC(&size);

pOleObject->SetExtent(DVASPECT_CONTENT,&size);

}

else

GetParentActiveXControl()->DelayControlsReposition();

}

}

}

 

BOOL
CSplitterWindowControlPropPage::OnInitDialog()

{

COlePropertyPage::OnInitDialog();

 

//
TODO: Add extra initialization here

long pointer=0;

GetPropText(_T("_pointer"),&pointer);

CCmdTarget* pCmdTarget=(CCmdTarget*)pointer;

if(pCmdTarget->IsKindOf(RUNTIME_CLASS(CSplitterWindowControlCtrl)))

{

CSplitterWindowControlCtrl*

pControl=(CSplitterWindowControlCtrl*)pCmdTarget;

 

CControlInfoArray arrayControls;

pControl->GetOtherControlsOnTheContainer(arrayControls);

for(int i=0; i<arrayControls.GetSize(); i++)

{

m_cbxFirstControlName.AddString(arrayControls[i].m_strName);

m_cbxSecondControlName.AddString(arrayControls[i].m_strName);

}

}

 

return FALSE;

}

void
CControlsSplitterWnd::OnInvertTracker(const CRect& rect)

{

ASSERT_VALID(this);

ASSERT(!rect.IsRectEmpty());

//ASSERT((GetStyle() & WS_CLIPCHILDREN) == 0);

 

CRect rectContainer(rect);

ClientToScreen(rectContainer);

CWnd wndContainer;

IOleClientSitePtr
pOleClientSite=GetParentActiveXControl()->GetClientSite();

wndContainer.m_hWnd=GetContainerWindow(pOleClientSite);

wndContainer.ScreenToClient(rectContainer);

wndContainer.ScreenToClient(rectContainer);

DWORD dwOldStyle=wndContainer.GetStyle();

::SetWindowLong(wndContainer.m_hWnd,

GWL_STYLE,

dwOldStyle&~WS_CLIPCHILDREN);

 

//
pat-blt without clip children on

CDC* pDC = wndContainer.GetDC();

//
invert the brush pattern (looks just like frame window sizing)

CBrush* pBrush = CDC::GetHalftoneBrush();

HBRUSH hOldBrush = NULL;

if
(pBrush != NULL)

hOldBrush = (HBRUSH)SelectObject(pDC->m_hDC,
pBrush->m_hObject);

 

pDC->PatBlt(rectContainer.left,

rectContainer.top,

rectContainer.Width(),

rectContainer.Height(),

PATINVERT);

 

if
(hOldBrush != NULL)

SelectObject(pDC->m_hDC, hOldBrush);

 

ReleaseDC(pDC);

::SetWindowLong(wndContainer.m_hWnd,GWL_STYLE,dwOldStyle);

wndContainer.m_hWnd=NULL;

}

‘$$TypeLib: Excel.Sheet

Well, the most things are described. If you have any
ideas, information, code snippets use andrew@skif.net.
If you have questions about COM use the same address. If you are interested in
Dundas products, you might want to go http://www.dundas.com