The call on the first phase constructor method of the view occurs in UI controller. The view serves as the top-level window under the UI controller.
The methods you need to implement for your CCoeControl-derived
view are as follows:
C++ default constructor, which cannot contain code that leaves. A common implementation is:
CMyAppView* CMyAppView::NewL( const TRect& aRect )
{
CMyAppView* self = CMyAppView::NewLC( aRect );
CleanupStack::Pop( self );
return self;
}
CMyAppView* CMyAppView::NewLC( const TRect& aRect )
{
CMyAppView* self = new ( ELeave ) CMyAppView;
CleanupStack::PushL( self );
self->ConstructL( aRect );
return self;
}
CMyAppView::CMyAppView()
{
// No implementation required
}
The declarations for CMyAppView::NewL and CMyAppView::NewLC in
the class header file needs to be public to support the construction method
required.
In this approach, CMyAppView::NewL is called from
the UI controller. It creates a view object by calling CMyAppView::NewLC. CMyAppView::NewLC calls
new (ELeave) on the C++ default constructor CMyAppView to
create the object (and leave if it cannot), pushes a pointer to the clean-up stack in case the second phase construction method
leaves, and then calls the second phase construction method of the object.
When it returns to CMyAppView::NewL, the pointer pushed
to the cleanup stack is removed.
Symbian 2nd phase constructor with code that might leave. A common implementation is:
void CMyAppView::ConstructL( const TRect& aRect )
{
// Create a window for this application view
CreateWindowL();
//add construction for other controls if required
// Set the windows size
SetRect( aRect );
// Activate the window, which makes it ready to be drawn
ActivateL();
}
CMyAppView::ConstructL is a private class providing
the second phase construction that accepts the rectangle the view is drawn
to.
CCoeControl::CreateWindowL creates a window
for the control. Note that this window is a child of the UI controller. This
method makes the control a window-owning
control. While, the use of window-owning controls is discouraged to
prevent the taxing of run-time resources, this is the top-level window for
the UI controller.
While this is a simple control that does not contain other controls,
other controls could be added to the control between CCoeControl::CreateWindowL and CCoeControl::SetRect(aRect). For more information,
see Compound controls in S60 view architecture.
CCoeControl::SetRect(aRect) sets the window
size according to the requirements of the mobile device. The top-level control
rectangle is set to the area that the framework provides for the application.
Calling SetRect calls the CCoeControl::SizeChanged method, where the control should set the position and size
for any child controls and thus adjust the control layout to the UI.
CCoeControl::ActivateL sets the control
as ready to be drawn.
If required for your application, you may need to implement other methods
for your control. For top-level windows, you would need to implement CCoeControl::SizeChanged to respond to
changes to the size and position of the contents of this control. This is
called by the S60 platform when a change occurs. A typical implementation
for a compound control is:
void CMyAppView::SizeChanged()
{
// Control resize code
iControl->SetExtent( const TPoint &aPosition, const TSize &aSize);
}