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()
{
// No implementation required
}
two-phase constructor, a common implementation is:
static CMyAppView* CMyAppView::NewL( const TRect& aRect )
{
CMyAppView* self = CMyAppView::NewLC( aRect );
CleanupStack::Pop( self );
return self;
}
static CMyAppView* CMyAppView::NewLC( const TRect& aRect )
{
CMyAppView* self = new ( ELeave ) CMyAppView;
CleanupStack::PushL( self );
self->ConstructL( aRect );
return self;
}
The declarations for CMyAppView::NewL() and CMyAppView::NewLC in the class header file
needs to be public to support the construction method required. CMyAppView is the default constructor for the CMyAppView class and it is private.
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 generally discouraged
to prevent the taxing of run-time resources, this is the top-level
window for the UI controller.
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 traditional 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 CCoeControl::SetRect(aRect) 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 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);
}