Constructing +views in the view architecture

diff -r 000000000000 -r 89d6a7a84779 Symbian3/SDK/Source/GUID-1A26BD9E-5B8E-4E6D-904E-B8354B14E111.dita --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Symbian3/SDK/Source/GUID-1A26BD9E-5B8E-4E6D-904E-B8354B14E111.dita Thu Jan 21 18:18:20 2010 +0000 @@ -0,0 +1,104 @@ + + + + + +Constructing +views in the view architecture +

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 the 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 Symbian 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); + } + \ No newline at end of file