Constructing views in traditional 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()
      {
      // 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);
    }