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);
}