MCL/sf/app/commonemail: comparison meetingrequest/mrgui/src/cmrfieldcontainer.cpp

equal deleted inserted replaced

-:efd4f1afd43e
+:d620048b4810
 //DEBUG
 #include "emailtrace.h"
 namespace { // codescanner::namespace
+// Off screen field x coordinate
+const TInt KOffScreenPositionX =  1000;
 /**
 * Vertical scroll margin
 */
 const TInt KVerticalScrollMargin = 3;
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::NewL
 // ---------------------------------------------------------------------------
 //
 CMRFieldContainer* CMRFieldContainer::NewL(
 MESMRFieldStorage& aFactory,
 const CCoeControl& aParent )
 {
 FUNC_LOG;
 CMRFieldContainer* self = new( ELeave )CMRFieldContainer( aFactory );
 CleanupStack::PushL( self );
 void CMRFieldContainer::ConstructL( const CCoeControl& aParent )
 {
 FUNC_LOG;
 CCoeControl::SetComponentsToInheritVisibility( ETrue );
 SetContainerWindowL( aParent );
 TBool focusSet( EFalse );
 const TInt count( iFactory.Count() );
 for ( TInt i = 0; i < count; i++ )
 {
 iFactory.Field(i)->SetContainerWindowL( *this );
 {
 CESMRField* field = iFactory.Field( i );
 // Initialize field
 field->InitializeL();
-User::LeaveIfError( field->SetParent( this ) );
 if ( !focusSet
 && field->IsVisible()
 && !field->IsNonFocusing())
 {
 //
 TKeyResponse CMRFieldContainer::MoveFocusUpL( TBool aHiddenFocus )
 {
 FUNC_LOG;
 /*
 * Moves focus up after key event. If aHiddenFocus, moves focus
 * to the first visible field in the bottom of the viewable area.
 */
 if( aHiddenFocus )
 {
 return MoveFocusVisibleL();
 }
 else
 {
 field->SetPreItemIndex( iFocusedFieldIndex );
 iFocusedFieldIndex = ind;
 field->SetCurrentItemIndex( iFocusedFieldIndex );
 // Remove focus from previous position
 focusedField->SetOutlineFocusL( EFalse );
 focusedField->SetFocus( EFalse );
+focusedField->MoveToScreen( EFalse );
 // Set focus to new position
 field->SetOutlineFocusL( ETrue );
 field->SetFocus( ETrue );
+field->MoveToScreen( ETrue );
 // Scrollbar and physics update is done here
 ScrollControlVisible( iFocusedFieldIndex );
 DrawDeferred();
 }
 return EKeyWasConsumed;
 }
 //
 TKeyResponse CMRFieldContainer::MoveFocusDownL( TBool aHiddenFocus )
 {
 FUNC_LOG;
 /*
 * Moves focus down after key event. If aHiddenFocus, moves focus
 * to the first visible field in the top of the viewable area.
 */
 if( aHiddenFocus )
 {
 return MoveFocusVisibleL();
 }
 else
 {
 field->SetPreItemIndex( iFocusedFieldIndex );
 iFocusedFieldIndex = ind;
 field->SetCurrentItemIndex( iFocusedFieldIndex );
 // Remove focus from previous position
 focusedField->SetOutlineFocusL( EFalse );
 focusedField->SetFocus( EFalse );
+focusedField->MoveToScreen( EFalse );
 // Set focus to new position
 field->SetOutlineFocusL( ETrue );
 field->SetFocus( ETrue );
+field->MoveToScreen( ETrue );
 // Scrollbar and physics update is done here
 ScrollControlVisible( iFocusedFieldIndex );
 DrawDeferred();
 }
 return EKeyWasConsumed;
 }
 //
 TKeyResponse CMRFieldContainer::MoveFocusVisibleL()
 {
 FUNC_LOG;
 /*
 * Move focus to first completely visible field in the view,
 * if focus was in a field that was not visible in the view.
 * Use case: After pointer scroll focus is hidden. User presses
 * arrow keys -> Focus appears to the first visible field on the upper
 * or bottom part of the viewable area.
 */
 TKeyResponse response( EKeyWasNotConsumed );
 CESMRField* focusedField = FocusedField();
 CESMRField* visibleField = NULL;
 TRect view( Parent()->Rect() );
 if ( visibleField )
 {
 // Remove existing focus
 focusedField->SetOutlineFocusL( EFalse );
 focusedField->SetFocus( EFalse );
 // Set focus to new field
 visibleField->SetOutlineFocusL( ETrue );
 visibleField->SetFocus( ETrue );
 response = EKeyWasConsumed;
 DrawDeferred();
 }
 return response;
 }
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::SetFieldContainerObserver
 // ---------------------------------------------------------------------------
 //
 void CMRFieldContainer::SetFieldContainerObserver(
 MMRFieldContainerObserver* aObserver )
 {
 FUNC_LOG;
 iObserver = aObserver;
 }
 // ---------------------------------------------------------------------------
 //
 TInt CMRFieldContainer::CountComponentControls() const
 {
 FUNC_LOG;
-return iFactory.Count();
+// If field container is scrolling, container will draw also children
+TInt count( 0 );
+if ( !iScrolling )
+{
+count = iFactory.Count();
+}
+return count;
 }
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::ComponentControl
 // ---------------------------------------------------------------------------
 {
 FUNC_LOG;
 /*
 * Returns the minimum size required by the field container
 */
 TSize containerSize;
+// Calculate height as the sum of the heights of the visible fields
 const TInt count( iFactory.Count() );
 for ( TInt i(0); i < count; ++i )
 {
 CESMRField* field = iFactory.Field( i );
 if ( field->IsVisible() )
 {
 TRect rect( field->Rect() );
 containerSize.iHeight += rect.Height();
 }
 }
 containerSize.iWidth = Parent()->Rect().Width();
 return containerSize;
 }
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::SizeChanged
 // ---------------------------------------------------------------------------
 //
 void CMRFieldContainer::SizeChanged()
 {
 FUNC_LOG;
-// TEST CODE:
+// For example when orientation changes, we might need to scroll
-TRect fieldcontainerRect = Rect();
-TRect parentRect = Parent()->Rect();
-// For example when orientation changes, we might need to scroll
 // the currently focused control visible again. This handles also
 // scrollbar and physics updates.
 ScrollControlVisible( KErrNotFound );
 TPoint tl( Position() );
 const TInt count( iFactory.Count() );
 // Loop all the visible fields and set size and position in the list
 {
 CESMRField* field = iFactory.Field( i );
 if ( field->IsVisible() )
 {
-LayoutField( *field, tl );
+TPoint pos( tl );
+// If field is not focused, layout it outside screen
+if ( i != iFocusedFieldIndex )
+{
+pos.iX = KOffScreenPositionX;
+}
+LayoutField( *field, pos );
 TInt height = field->Size().iHeight;
 tl.iY += height;
 }
 }
 }
+// ---------------------------------------------------------------------------
+// CMRFieldContainer::HandlePointerEventL
+// ---------------------------------------------------------------------------
+//
+void CMRFieldContainer::HandlePointerEventL( const TPointerEvent &aPointerEvent )
+{
+FUNC_LOG;
+// Find out to which field this pointer event is intended to
+TInt fieldCount( iFactory.Count() );
+for( TInt i = 0; i < fieldCount; ++i )
+{
+CCoeControl* field = iFactory.Field( i );
+if( field->Rect().Contains( aPointerEvent.iPosition ) &&
+field->IsVisible() )
+{
+field->HandlePointerEventL( aPointerEvent );
+}
+}
+}
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::ControlSizeChanged
 // ---------------------------------------------------------------------------
 //
 void CMRFieldContainer::ControlSizeChanged( CESMRField* aField )
 {
 FUNC_LOG;
 /*
 * Called whenever a fields size has changed. Requires always
 * relayouting.
 */
 if ( !aField )
 {
 SizeChanged();
 TSize old( aField->Size() );
 TSize size( aField->MinimumSize() );
 if( size != old )
 {
 aField->SetSize( size );
 TPoint tl( aField->Position() );
 TInt index = IndexByFieldId( iFactory, aField->FieldId() );
 // Move fields below this particular field
 tl.iY += size.iHeight;
 MoveFields( index + 1, tl );
 // Fields have been re-layouted / moved. This requires resetting
 // the size of this field container.
-SetSize( MinimumSize() );
+SetSizeWithoutNotification( MinimumSize() );
 // Update also scrollbar and physics
 iObserver->UpdateScrollBarAndPhysics();
-if( index == iFocusedFieldIndex )
+if( index <= iFocusedFieldIndex )
 {
 // Scroll this field completely visible, if required.
 // This updates also scrollbar and physics if scrolling
 // is done.
 ScrollControlVisible( iFocusedFieldIndex );
 }
 DrawDeferred();
 }
 }
 }
 {
 FUNC_LOG;
 /*
 * Inserts field visible and layouts it.
 */
 CESMRField* field = iFactory.FieldById( aFieldId );
 if ( field && !field->IsVisible() )
 {
 // Make field visible
 TPoint tl( Rect().iTl );
 TInt prevIndex = index - 1;
 // Get previous visible field position
 // Index 0 must be included in attendee field case,
 // to avoid field collision. But in response field,
 // causes misplacing of area.
 if ( ( prevIndex >= 0 ) && ( aFieldId != EESMRFieldResponseArea ) )
 {
 CESMRField* previous = NULL;
 do
 tl.iY = previous->Rect().iBr.iY;
 }
 // Layout field
 LayoutField( *field, tl);
+// Move field off screen if it is not focused
+field->MoveToScreen( index == iFocusedFieldIndex );
 // Move following fields
 tl.iY += field->Size().iHeight;
 MoveFields( ++index, tl );
 // Set fieldcontainer size again, because
 // the amount of fields has changed.
-SetSize( MinimumSize() );
+SetSizeWithoutNotification( MinimumSize() );
 // Scrollbar and physics require updating.
 iObserver->UpdateScrollBarAndPhysics();
 }
 DrawDeferred();
 }
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::HideControl()
 void CMRFieldContainer::HideControl( TESMREntryFieldId aFieldId )
 {
 FUNC_LOG;
 /*
 * Sets field non-visible and moves other fields accordingly.
 * Does not delete the field.
 */
 CESMRField* field = iFactory.FieldById( aFieldId );
 if ( field && field->IsVisible() )
 {
 TBool focused = ( index == iFocusedFieldIndex )? ETrue : EFalse;
 TPoint pos( field->Position() );
 MoveFields( index, pos );
 // Set fieldcontainer size again, because
 // the amount of fields has changed.
-SetSize( MinimumSize() );
+SetSizeWithoutNotification( MinimumSize() );
 // Scrollbar and physics require updating.
 iObserver->UpdateScrollBarAndPhysics();
 if ( focused && !field->IsNonFocusing() )
 {
 // Set focus to next field, or if removed field was the last
 // field, then move focus to last visible field
 TInt lastVisibleFieldIndex( LastVisibleField( aFieldId ) );
 // If field was the last one...
 if( lastVisibleFieldIndex == index )
 {
 // ... Set focus to last visible field.
 TRAP_IGNORE( DoSetFocusL( lastVisibleFieldIndex ) )
 //
 TBool CMRFieldContainer::IsControlVisible( TESMREntryFieldId aField )
 {
 FUNC_LOG;
 /*
 * Returns ETrue/EFalse if the field with given field id is
 * visible or not.
 */
 TBool ret( EFalse );
 CESMRField* field = iFactory.FieldById( aField );
 if ( field && field->IsVisible() )
 {
 //
 TBool CMRFieldContainer::IsFocusedControlsBottomVisible()
 {
 FUNC_LOG;
 /*
 * Checks if focused field is completely visible in the viewable area.
 */
 // Fetch the position information about currently focused field:
 CESMRField* field = iFactory.Field( iFocusedFieldIndex );
 TBool ret( EFalse );
 if ( field->Rect().iBr.iY <= Parent()->Rect().iBr.iY )
 {
 {
 FUNC_LOG;
 /*
 * Scrolls the field with the given index visible
 */
 CESMRField* field = NULL;
 if ( aInd == KErrNotFound )
 {
 field = FocusedField();
 }
 {
 field = iFactory.Field( aInd );
 }
 ASSERT( field );
 TRect fieldRect( field->Position(), field->Size() );
 TRect parentRect( Parent()->Rect() );
 /*
 * Case 1: Field's height is less than the viewable area height,
 * let's scroll the whole field visible.
 */
 if( fieldRect.Height() < parentRect.Height() )
 {
 // Scrolling down, let's move fields up
 if( fieldRect.iBr.iY > parentRect.iBr.iY )
 {
 iObserver->ScrollFieldsUp(
 fieldRect.iBr.iY - parentRect.iBr.iY );
 }
 // scrolling up, let's move field down
 if( fieldRect.iTl.iY < parentRect.iTl.iY )
 {
 iObserver->ScrollFieldsDown(
 parentRect.iTl.iY - fieldRect.iTl.iY );
 }
 }
 /*
 * Case 2: Field's height is more than the viewable area's height.
 */
 else
 {
 if( field->FieldMode() == EESMRFieldModeView )
 {
 // Focus to this field is coming from above
 if( field->PreItemIndex() < field->CurrentItemIndex() )
 {
 // Let's scroll the top of the field to the
 // top of the viewable area
 iObserver->ScrollFieldsUp(
 fieldRect.iTl.iY - parentRect.iTl.iY );
 }
 // Focus to this field is coming from below
 if( field->PreItemIndex() > field->CurrentItemIndex() )
 {
 // Let's scroll the bottom of the field to the
 // bottom of the viewable area
 iObserver->ScrollFieldsDown(
 parentRect.iBr.iY - fieldRect.iBr.iY );
 }
 }
 // Field is in edit mode
 if( field->FieldMode() == EESMRFieldModeEdit )
 {
 TInt viewBottom( parentRect.iBr.iY );
 if ( focusFieldVisibleBottom > viewBottom )
 {
 // move field focus line bottom to view bottom
 TInt px = focusFieldVisibleBottom - viewHeight;
 // if focus on last field: add margin height to
 // scroll amount.
 if ( iFocusedFieldIndex == iFactory.Count()-1 )
 {
 px += KVerticalScrollMargin;
 }
 // Scrollbar and physics update is done here
 iObserver->ScrollFieldsUp( px );
 }
 else
 {
 // Scrollbar and physics update is done here
 iObserver->ScrollFieldsDown( px );
 }
 }
 }
 }
 }
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::RePositionFields
 // ---------------------------------------------------------------------------
 //
 void CMRFieldContainer::RePositionFields( TInt aAmount )
 {
 FUNC_LOG;
 // Movement downwards
 if( aAmount >= 0 )
 {
 // Also scrollbar and physics update is done here
 iObserver->ScrollFieldsDown( aAmount );
 //
 void CMRFieldContainer::MoveFields( TInt aIndex, TPoint& aTl )
 {
 FUNC_LOG;
 /*
 * Moves fields from the given index towards the last item.
 * This function does not update scrollbar or physics.
 */
 const TInt count( iFactory.Count() );
 for ( TInt i = aIndex; i < count; ++i )
 {
 CESMRField* field = iFactory.Field( i );
 if ( field->IsVisible() )
 {
 field->SetPosition( aTl );
 aTl.iY += field->Size().iHeight;
 }
 }
 }
 FUNC_LOG;
 /*
 * Layouts given field according to the size required by the field and
 * given TPoint. This function does not update scrollbar or physics.
 */
 TSize size( aField.MinimumSize() );
-aField.SetPosition( aTl );
+aField.SetExtent( aTl, size );
-aField.SetSize( size );
 }
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::IsLastVisibleField
 // ---------------------------------------------------------------------------
 //
 TInt CMRFieldContainer::LastVisibleField(
 TESMREntryFieldId aFieldId )
 {
 /*
 * Helper function to find out the last visible field in the list.
 */
 TInt lastVisibleFieldIndex( 0 );
 TInt count( iFactory.Count() );
 // Go through fields from last field towards the first field
 for( TInt i( 1 ); i > count; ++i )
 {
 // Once last visible field is found...
 if( iFactory.Field( count - i )->IsVisible() )
 {
 // ... Compare it to the given field index ...
 if( iFactory.Field( count - i )->FieldId() == aFieldId )
 {
 // ... And if match is found, given fieldId is the
 // the last visible field.
 lastVisibleFieldIndex =
 IndexByFieldId( iFactory, aFieldId );
 }
 else
 {
 // Otherwise return the found last visible field.
 lastVisibleFieldIndex =
 IndexByFieldId( iFactory,
 iFactory.Field( count - i )->FieldId() );
 }
 break;
 }
 }
 return lastVisibleFieldIndex;
 }
 // ---------------------------------------------------------------------------
 // CMRFieldContainer::DoSetFocusL
 {
 FUNC_LOG;
 /*
 * Sets the focus according to the given index.
 */
 TInt count( iFactory.Count() );
 aNewFocusIndex = Max( 0, Min( aNewFocusIndex, count - 1 ) );
 if ( aNewFocusIndex != iFocusedFieldIndex )
 {
 // Get current focused field
 CESMRField* old = iFactory.Field( iFocusedFieldIndex );
 // Get next focused field
 CESMRField* field = iFactory.Field( aNewFocusIndex );
 // Do sanity checks
 while ( aNewFocusIndex < count && !field->IsVisible() )
 {
 field = iFactory.Field( aNewFocusIndex++ );
 }
 field = iFactory.Field( aNewFocusIndex-- );
 }
 }
 ASSERT( field->IsVisible() );
 // Update current and previous item indexes
 field->SetPreItemIndex( iFocusedFieldIndex );
 iFocusedFieldIndex = aNewFocusIndex;
 field->SetCurrentItemIndex( iFocusedFieldIndex );
 // Remove focus from old
 old->SetOutlineFocusL( EFalse );
 old->SetFocus( EFalse );
+old->MoveToScreen( EFalse );
 // update focus index to new index
 field->SetOutlineFocusL( ETrue );
 field->SetFocus( ETrue );
+field->MoveToScreen( ETrue );
 // This handles also scrollbar and physics updating,
 // if view scrolling is done.
 ScrollControlVisible( iFocusedFieldIndex );
 DrawDeferred();
 }
 }
+// ---------------------------------------------------------------------------
+// CMRFieldContainer::SetScrolling
+// ---------------------------------------------------------------------------
+//
+void CMRFieldContainer::SetScrolling( TBool aScrolling )
+{
+FUNC_LOG;
+iScrolling = aScrolling;
+// Move focused field away from screen if container is scrolling.
+// Otherwise move it to screen.
+CESMRField* field = iFactory.Field( iFocusedFieldIndex );
+field->MoveToScreen( !iScrolling );
+}
+// ---------------------------------------------------------------------------
+// CMRFieldContainer::Draw
+// ---------------------------------------------------------------------------
+//
+void CMRFieldContainer::Draw( const TRect& aRect ) const
+{
+FUNC_LOG;
+// Get visible screen area from parent (list pane)
+TRect parent( Parent()->Rect() );
+// Current container position used to calculate actual field positions
+TPoint tl( iPosition );
+// Field index to skip
+TInt fieldToSkip = KErrNotFound;
+if ( !iScrolling )
+{
+// Container is not scrolling. Don't draw focused field from buffer
+fieldToSkip = iFocusedFieldIndex;
+}
+// Draw all visible fields which are not on screen
+TInt count( iFactory.Count() );
+for ( TInt i = 0; i < count; ++i )
+{
+CESMRField* field = iFactory.Field( i );
+if ( field->IsVisible() )
+{
+// Calculate actual field rect on screen
+TRect screenRect( tl, field->Size() );
+// Draw field if it intersects with screen visible area
+if ( i != fieldToSkip
+&& screenRect.Intersects( parent ) )
+{
+field->Draw( screenRect );
+}
+// Move next field top left corner
+tl.iY += screenRect.Height();
+}
+}
+}
+// ---------------------------------------------------------------------------
+// CMRFieldContainer::ScrollContainer
+// ---------------------------------------------------------------------------
+//
+void CMRFieldContainer::ScrollContainer( const TPoint& aTl )
+{
+FUNC_LOG;
+// Set scrolling flag and move focused field off screen
+SetScrolling( ETrue );
+// Update control position,
+// but dont propagate the change to component controls
+iPosition = aTl;
+}
+// ---------------------------------------------------------------------------
+// CMRFieldContainer::Synchronize
+// ---------------------------------------------------------------------------
+//
+void CMRFieldContainer::Synchronize()
+{
+FUNC_LOG;
+// Set actual control positions (y-coordinate) to visible fields
+TPoint tl( iPosition );
+TInt count( iFactory.Count() );
+for ( TInt i = 0; i < count; ++i )
+{
+CESMRField* field = iFactory.Field( i );
+if ( field->IsVisible() )
+{
+TPoint pos( field->Position().iX, tl.iY );
+tl.iY += field->Size().iHeight;
+field->SetPosition( pos );
+}
+}
+SetScrolling( EFalse );
+}
 // End of file

branch	RCL_3
changeset 22	d620048b4810
parent 16	b5fbb9b25d57