--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/idlehomescreen/exths/src/plugincontainer/caiplugincontainercontrol.cpp Thu Dec 17 08:40:49 2009 +0200
@@ -0,0 +1,1114 @@
+/*
+* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* It is the control container for the AI plugins
+*
+*/
+
+
+// INCLUDE FILES
+#include <bldvariant.hrh> //feature flags
+#include <barsread.h>
+#include <coecntrl.h>
+#include <e32std.h>
+#include <bautils.h>
+#include <e32property.h>
+#include <connect/sbdefs.h> // pub&sub keys and categories for backup and restore
+#include <aknappui.h>
+#include <AknsDrawUtils.h>
+#include <AknsLayeredBackgroundControlContext.h>
+#include <layoutmetadata.cdl.h>
+#include <AknUtils.h>
+#include <data_caging_path_literals.hrh>
+#include <centralrepository.h>
+#include <AIContainerDomainCRKeys.h>
+#include <activeidle2domainpskeys.h>
+#include "aicontainer.hrh"
+#include "caiplugincontainercontrol.h"
+#include "ExtrStandbyScr.h"
+
+
+const TInt KActOnSendKey = 1;
+
+// ================= MEMBER FUNCTIONS =======================
+
+CAIPluginContainerControl* CAIPluginContainerControl::NewL(CCoeControl *aContainer)
+ {
+ CAIPluginContainerControl* self =
+ new (ELeave) CAIPluginContainerControl() ;
+
+ CleanupStack::PushL( self );
+ self->ConstructL(aContainer);
+ CleanupStack::Pop(self);
+
+ return self;
+ }
+
+CAIPluginContainerControl::~CAIPluginContainerControl()
+ {
+
+ AknsUtils::DeregisterControlPosition(this);
+
+ delete iBackupObserver;
+ iBackupObserver = NULL;
+
+ if(iNotifyHandler)
+ {
+ iNotifyHandler->StopListening();
+ }
+ delete iNotifyHandler;
+ delete iAIRepository;
+ delete iBgContext;
+
+ DestroyPlugins() ;
+ iPlugins.ResetAndDestroy();
+ iPlugins.Close();
+ REComSession::FinalClose() ;
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::SetDimmed
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::SetDimmed(TBool aDimmed)
+ {
+ MakeVisible(!aDimmed);
+ if (iContentStatusChangedNotification)
+ {
+ iContentStatusChangedNotification = EFalse;
+ CalculateRectPlugins();
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::CountComponentControls
+// Counts the component controls, so it returns one.
+// ---------------------------------------------------------
+//
+TInt CAIPluginContainerControl::CountComponentControls() const
+ {
+ TInt pluginsCount = 0;
+
+ for ( TInt index = 0; index < iPlugins.Count(); index++ )
+ {
+ TPluginInfo* plugin = iPlugins[index];
+
+ if (plugin->iPlugin) pluginsCount++ ;
+ }
+
+ return pluginsCount;
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::ComponentControl
+// Returns components by index.
+// ---------------------------------------------------------
+//
+CCoeControl* CAIPluginContainerControl::ComponentControl(TInt aIndex) const
+ {
+ if (iPlugins.Count())
+ {
+ TInt pluginsPos = -1;
+
+ for ( TInt index = 0; index < iPlugins.Count(); index++ )
+ {
+ TPluginInfo* plugin = iPlugins[index];
+
+ if (plugin->iPlugin) pluginsPos++ ;
+
+ if (pluginsPos == aIndex) return iPlugins[index]->iPlugin;
+ }
+ }
+ return NULL ;
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::SizeChanged
+// Changes the sizes of the components.
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::SizeChanged()
+ {
+ AknsUtils::RegisterControlPosition(this);
+
+ if(iBgContext)
+ {
+ iBgContext->SetRect(Rect());
+ iBgContext->SetParentPos(PositionRelativeToScreen());
+ }
+
+
+ if (!CountComponentControls())
+ {
+ return ;
+ }
+
+ if ((iPrevRect.IsEmpty() || iPrevRect != Rect()))
+ {
+ CalculateRectPlugins() ;
+ iPrevRect = Rect() ;
+ }
+ else
+ {
+// FocusOnDefaultFocusingPlugin(EDrawNow);
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::FocusChanged
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::FocusChanged(TDrawNow /*aDrawNow*/)
+ {
+ if (iCurrentPlugin)
+ {
+ if (IsFocused())
+ {
+ TRAP_IGNORE(iCurrentPlugin->iPlugin->PrepareForFocusGainL());
+ }
+ else
+ {
+ TRAP_IGNORE(iCurrentPlugin->iPlugin->PrepareForFocusLossL());
+ }
+ // The flag must be drawnow because
+ // the plugin focusing have to be happer/disapper
+ iCurrentPlugin->iPlugin->SetFocus(IsFocused(),EDrawNow) ;
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::Draw
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::Draw( const TRect& /*aRect*/ ) const
+ {
+ if (IsDimmed())
+ {
+ return ;
+ }
+ TRect rect( Rect() );
+
+ CWindowGc& gc = SystemGc();
+
+ MAknsControlContext* cc = AknsDrawUtils::ControlContext( this);
+ MAknsSkinInstance* aknsInst = AknsUtils::SkinInstance();
+
+ // Draw background starting from correct offset
+ AknsDrawUtils::Background( aknsInst, cc, this, gc, rect );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CAIPluginContainerControl::MopSupplyObject
+// -----------------------------------------------------------------------------
+//
+TTypeUid::Ptr CAIPluginContainerControl::MopSupplyObject(TTypeUid aId)
+ {
+ if( aId.iUid == MAknsControlContext::ETypeId )
+ {
+ return MAknsControlContext::SupplyMopObject( aId, iBgContext );
+ }
+ return CCoeControl::MopSupplyObject( aId );
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::OfferKeyEventL
+// Processes the key event for the incall view.
+// ---------------------------------------------------------
+//
+TKeyResponse CAIPluginContainerControl::OfferKeyEventL(
+ const TKeyEvent& aKeyEvent,
+ TEventCode aType )
+ {
+
+ if (iCurrentPlugin)
+ {
+ if (CountComponentControls() > 1)
+ {
+ switch( aKeyEvent.iScanCode )
+ {
+ case EStdKeyUpArrow:
+ case EStdKeyDownArrow:
+ {
+ if( aKeyEvent.iCode == EKeyUpArrow )
+ {
+ ChangeFocusPluginL(EAIFocusUp);
+ }
+ else if( aKeyEvent.iCode == EKeyDownArrow )
+ {
+ ChangeFocusPluginL(EAIFocusDown);
+ }
+ return EKeyWasConsumed;
+ }
+ }
+ }
+
+ if( aKeyEvent.iCode == EKeyPhoneEnd )
+ {
+ FocusOnDefaultFocusingPlugin(EDrawNow);
+ }
+ return iCurrentPlugin->iPlugin->OfferKeyEventL(aKeyEvent,aType);
+ }
+ return EKeyWasNotConsumed;
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::HandleResourceChange
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::HandleResourceChange( TInt aType )
+ {
+ switch(aType)
+ {
+ case KAknsMessageSkinChange:
+ {
+ iPrevRect.SetSize(TSize(0,0));
+ }
+ break;
+
+ case KEikDynamicLayoutVariantSwitch:
+ {
+ TRAP_IGNORE(UpdateBackgroundL());
+ SetRect(static_cast<CAknAppUi*>(iEikonEnv->AppUi())->ClientRect());
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ CCoeControl::HandleResourceChange( aType );
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::StartL
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::StartL()
+ {
+ // Avoid double start calls
+ if(!iStarted)
+ {
+ iStarted = ETrue;
+ ReadPluginsConfigurationsL() ;
+ LoadPluginsL();
+ SizeChanged();
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::SetFullScreenMode
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::SetFullScreenMode(TBool aFullScreenMode)
+ {
+ iIsFullScreenMode = aFullScreenMode;
+ TRAP_IGNORE(UpdateBackgroundL());
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::HandleControlEventL
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::HandleControlEventL(CCoeControl* /*aControl*/,TCoeEvent aEventType)
+ {
+ if ( aEventType == EEventStateChanged )
+ {
+ if (IsDimmed())
+ {
+ iContentStatusChangedNotification = ETrue ;
+ return ;
+ }
+ CalculateRectPlugins() ;
+ //DrawNow();
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::HandlePropertyChange
+// From PropertyObserver
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::HandlePropertyChange(const TUid& /*aCategory*/,
+ const TUint& /*aKey*/,
+ const TInt& aValue)
+ {
+ // see \epoc32\include\connect\sbdefs.h for enum descriptions
+
+ const TUint backupMask( conn::KBURPartTypeMask ^ conn::EBURNormal );
+
+ if( aValue & backupMask ) // any type of backup or restore operation
+ {
+ // backup or restore started
+ // -> unload plugins
+ if (CountComponentControls())
+ {
+ DestroyPlugins();
+ DrawNow() ;
+ }
+ }
+ else // aValue == conn::EBURUnset || aValue & conn::EBURNormal
+ {
+ // backup or restore ended
+ // -> load plugin again
+ if (CountComponentControls() == 0)
+ {
+ TRAP_IGNORE(
+ ReadPluginsConfigurationsL();
+ LoadPluginsL()
+ );
+ CalculateRectPlugins();
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAIPluginContainerControl::HandleNotifyGeneric
+// -----------------------------------------------------------------------------
+//
+void CAIPluginContainerControl::HandleNotifyGeneric(TUint32 aId)
+ {
+ if(aId != NCentralRepositoryConstants::KInvalidNotificationId)
+ {
+ if(aId != KAINumOfOperatorPlugins)
+ {
+ RProperty::Set( KPSUidAiInformation, KActiveIdleExtHS_LSKLocked, KNullDesC );
+ RProperty::Set( KPSUidAiInformation, KActiveIdleExtHS_RSKLocked, KNullDesC );
+ DestroyPlugins();
+ TRAP_IGNORE(ReadPluginsConfigurationsL(); LoadPluginsL(););
+ CalculateRectPlugins();
+ RProperty::Set( KPSUidAiInformation, KActiveIdleExtHS_PluginConfChange, 1 );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::ReadPluginsConfigurationsL
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::ReadPluginsConfigurationsL()
+ {
+ TInt numOfPlugins = 0;
+ TInt error(KErrNone);
+ error = iAIRepository->Get( KAINumOfOperatorPlugins, numOfPlugins );
+
+ if( error == KErrNone )
+ {
+ // Reset old array
+ iPlugins.ResetAndDestroy();
+
+ // Load operator plug-in UIDs
+ TInt uid = 0;
+ for(TInt i = 1; i <= numOfPlugins; i++)
+ {
+ error = iAIRepository->Get( KAINumOfOperatorPlugins+i, uid );
+
+ if( error == KErrNone )
+ {
+ TPluginInfo* pluginItem = new ( ELeave ) TPluginInfo;
+ CleanupStack::PushL( pluginItem );
+
+ // Define values
+ ResetToDefault( *pluginItem );
+ pluginItem->iPluginId.iUid = TUid::Uid(uid).iUid;
+
+ iPlugins.AppendL( pluginItem );
+ CleanupStack::Pop(); // pluginItem
+ }
+ }
+ }
+
+ iIndexDefaultFocusingPlugin = 0;
+ }
+
+// -----------------------------------------------------------------------------
+// CAIPluginContainerControl::LoadPluginsL
+// -----------------------------------------------------------------------------
+//
+void CAIPluginContainerControl::LoadPluginsL()
+ {
+ // Set send key functionality to default
+ RProperty::Set(
+ KPSUidAiInformation,
+ KActiveIdleActOnSendKey,
+ KActOnSendKey );
+ for ( TInt index = 0; index < iPlugins.Count() ; index++)
+ {
+ LoadPluginL(index) ;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAIPluginContainerControl::LoadPluginL
+// -----------------------------------------------------------------------------
+//
+void CAIPluginContainerControl::LoadPluginL(TInt aIndex)
+ {
+ CExtrStandbyScr* currentPlugin = NULL;
+
+ TPluginInfo *pluginItem = iPlugins[aIndex];
+
+ if (pluginItem->iState == EAIPluginOn)
+ {
+ TRAPD(err, currentPlugin = CExtrStandbyScr::NewL(pluginItem->iPluginId,this)) ;
+
+ if ( err != KErrNone )
+ {
+ pluginItem->iState = EAIPluginError ;
+ }
+ else
+ {
+
+ if ( err == KErrNone )
+ {
+ TSize MinSize = currentPlugin->GetMinSize() ;
+ TSize MaxSize = currentPlugin->GetMaxSize() ;
+ pluginItem->iResizeable = MinSize != MaxSize ;
+
+ currentPlugin->SetObserver(this) ;
+
+ TRAP_IGNORE(currentPlugin->LoadEngineL()) ;
+ }
+
+ if ( err != KErrNone )
+ {
+ delete currentPlugin ;
+ pluginItem->iState = EAIPluginError ;
+ }
+ else
+ {
+ //currentPlugin->SetDimmed(ETrue) ;
+ pluginItem->iPlugin = currentPlugin ;
+ pluginItem->iPlugin->ActivateL();
+ }
+ }
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CAIPluginContainerControl::DestroyPluginsL
+// -----------------------------------------------------------------------------
+//
+void CAIPluginContainerControl::DestroyPlugins()
+ {
+ TInt index;
+
+ for ( index = 0; index < iPlugins.Count(); index++ )
+ {
+ TPluginInfo* plugin = iPlugins[index];
+
+ if (plugin->iPlugin)
+ {
+ delete plugin->iPlugin;
+ plugin->iPlugin = NULL;
+ }
+ }
+ iPlugins.ResetAndDestroy();
+ iIndexPlugin = -1;
+ iCurrentPlugin = NULL ;
+ }
+
+// ----------------------------------------------------------------------------
+// CAIPluginContainerControl::ResetToDefault
+// ----------------------------------------------------------------------------
+//
+void CAIPluginContainerControl::ResetToDefault( TPluginInfo& aPluginInfo )
+ {
+ aPluginInfo.iPlugin = NULL;
+ aPluginInfo.iResizeable = EFalse;
+ aPluginInfo.iOnScreen = EFalse;
+ aPluginInfo.iPluginId.iUid = 0;
+ aPluginInfo.iAlignment = EAITop;
+ aPluginInfo.iWeight = 0;
+ aPluginInfo.iCRKeyId = 0;
+ aPluginInfo.iState = EAIPluginOn;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CAIPluginContainerControl::IsInFullScreenModeL
+// ----------------------------------------------------------------------------
+//
+TBool CAIPluginContainerControl::IsInFullScreenModeL()
+ {
+ return iIsFullScreenMode;
+ }
+
+// ----------------------------------------------------------------------------
+// CAIPluginContainerControl::UpdateBackgroundL
+// ----------------------------------------------------------------------------
+//
+void CAIPluginContainerControl::UpdateBackgroundL()
+ {
+ delete iBgContext;
+ iBgContext = NULL;
+
+ CAknAppUi* appui = static_cast<CAknAppUi*>(iEikonEnv->AppUi());
+ TRect rect = appui->ClientRect();
+ TAknsItemID backSkinId;
+
+ if(IsInFullScreenModeL() && !Layout_Meta_Data::IsLandscapeOrientation())
+ {
+ backSkinId = KAknsIIDQsnBgScreen;
+ }
+ else
+ {
+ backSkinId = KAknsIIDQsnBgAreaMainIdle;
+ }
+
+ iBgContext = CAknsLayeredBackgroundControlContext::NewL(
+ backSkinId,
+ rect,
+ ETrue,
+ EAIBgLayersN );
+
+ iBgContext->SetLayerImage(
+ EAIBgLayerWallpaper,
+ KAknsIIDWallpaper );
+
+ TSize wallpapersize;
+ AknLayoutUtils::LayoutMetricsSize(AknLayoutUtils::EWallpaperPane, wallpapersize );
+
+ TRect wallpaperrect(wallpapersize);
+ wallpaperrect.Move(0, rect.Size().iHeight - wallpapersize.iHeight);
+
+ iBgContext->SetLayerRect(
+ EAIBgLayerWallpaper,
+ wallpaperrect );
+
+ iBgContext->SetParentPos(PositionRelativeToScreen());
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::CAIPluginContainerControl
+// ---------------------------------------------------------
+//
+CAIPluginContainerControl::CAIPluginContainerControl()
+ {
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::ConstructL
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::ConstructL( CCoeControl* aContainer )
+ {
+ iContainer = aContainer;
+ CreateWindowL();
+ SetParent(iContainer);
+
+ UpdateBackgroundL();
+
+ iAIRepository = CRepository::NewL( KCRUidActiveIdle );
+ iNotifyHandler = CCenRepNotifyHandler::NewL(*this, *iAIRepository);
+ iNotifyHandler->StartListeningL();
+
+ // backup/restore observer
+ iBackupObserver = CPropertyObserver::NewL(*this, KUidSystemCategory, conn::KUidBackupRestoreKey);
+
+ iIndexPlugin = -1;
+ ActivateL();
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::ChangeFocusPluginL
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::ChangeFocusPluginL(TInt aDirection)
+ {
+ if (!iCurrentPlugin)
+ {
+ return ;
+ }
+ iCurrentPlugin->iPlugin->PrepareForFocusLossL();
+ iCurrentPlugin->iPlugin->SetFocus(EFalse,EDrawNow) ;
+ switch(aDirection)
+ {
+ case EAIFocusDown:
+ iIndexPlugin = NextVisiblePlugin(iIndexPlugin+1) ;
+ break ;
+ case EAIFocusUp:
+ iIndexPlugin = PreviousVisiblePlugin(iIndexPlugin-1) ;
+ break ;
+ default:
+ User::Leave(KErrNotSupported) ;
+ }
+ if (iIndexPlugin == -1)
+ {
+ iCurrentPlugin = NULL ;
+ }
+ else
+ {
+ iCurrentPlugin = iPlugins[iIndexPlugin];
+ iCurrentPlugin->iPlugin->PrepareForFocusGainL();
+ iCurrentPlugin->iPlugin->SetFocus(ETrue,EDrawNow) ;
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::FocusOnDefaultFocusingPlugin
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::FocusOnDefaultFocusingPlugin(TDrawNow aDrawNow)
+ {
+ if (!CountComponentControls())
+ {
+ return ;
+ }
+ TInt index = NextVisiblePlugin(iIndexDefaultFocusingPlugin) ;
+ if (index != iIndexPlugin)
+ {
+ if (iCurrentPlugin)
+ {
+ TRAP_IGNORE(iCurrentPlugin->iPlugin->PrepareForFocusLossL()); //TRAPPED
+ iCurrentPlugin->iPlugin->SetFocus(EFalse,aDrawNow) ;
+ }
+ iIndexPlugin = index;
+ }
+ if (iIndexPlugin == -1)
+ {
+ iCurrentPlugin = NULL ;
+ }
+ else
+ {
+ /*if (iCurrentPlugin && iCurrentPlugin->iPlugin->IsFocused())
+ {
+ return;
+ }
+ */
+ iCurrentPlugin = iPlugins[iIndexPlugin];
+ TRAP_IGNORE(iCurrentPlugin->iPlugin->PrepareForFocusGainL()); //TRAPPED
+ iCurrentPlugin->iPlugin->ResetToDefaultState();
+ iCurrentPlugin->iPlugin->SetFocus(ETrue,aDrawNow) ;
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::CalculateRectPlugins
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::CalculateRectPlugins()
+ {
+ if (CountComponentControls() == 0)
+ {
+ DrawNow();
+ return ;
+ }
+
+ TInt paneHeight = Rect().Height();
+
+ TInt topPluginX=0;
+ TInt bottomPluginX=paneHeight;
+
+ for ( TInt index = 0; index < iPlugins.Count(); index++)
+ {
+ iPlugins[index]->iOnScreen = EFalse ;
+ }
+
+ HandleTopPlugins(topPluginX,bottomPluginX) ;
+ HandleBottomPlugins(topPluginX,bottomPluginX) ;
+
+ if (iIndexPlugin == -1)
+ {
+ FocusOnDefaultFocusingPlugin();
+ }
+
+ DrawNow();
+ }
+
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::HandleTopplugins
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::HandleTopPlugins(TInt& aTopPluginX, TInt& aBottomPluginX)
+ {
+
+ for ( TInt index = 0; index < iPlugins.Count(); index++)
+ {
+ HandlePlugin(index,EAITop,aTopPluginX,aBottomPluginX);
+ } // for all plugins
+
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::HandleBottomPlugins
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::HandleBottomPlugins(TInt& aTopPluginX, TInt& aBottomPluginX)
+ {
+ for ( TInt index = iPlugins.Count() -1 ; index >= 0 ; index--)
+ {
+ HandlePlugin(index,EAIBottom,aTopPluginX,aBottomPluginX);
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::HandlePlugin
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::HandlePlugin(TInt aIndex,
+ TAIPluginAlignment aAlign,
+ TInt& aTopPluginX,
+ TInt& aBottomPluginX)
+ {
+ TRect rectPlugin ; //Rect of the current plugin
+
+ TPluginInfo* pluginItem = iPlugins[aIndex];
+
+ if ((pluginItem->iPlugin) && (pluginItem->iAlignment == aAlign))
+ {
+ TSize plugSize = pluginItem->iPlugin->GetPreferedSize();
+
+ if ((plugSize.iHeight>0) && (plugSize.iWidth >0))
+ {
+ pluginItem->iOnScreen = ETrue;
+
+ TInt overRunHeight = 0 ;
+
+ if (pluginItem->iAlignment == EAITop)
+ {
+ if ((aTopPluginX+plugSize.iHeight) > aBottomPluginX)
+ {
+ overRunHeight = aTopPluginX+plugSize.iHeight-aBottomPluginX ;
+ }
+ }
+ else
+ {
+
+ if ((aBottomPluginX-plugSize.iHeight) < aTopPluginX)
+ {
+ overRunHeight = aTopPluginX-(aBottomPluginX-plugSize.iHeight) ;
+ }
+ }
+ if (overRunHeight)
+ {
+
+ while (overRunHeight > 0)
+ { // loop finding reduceable plugins from the first to the current
+ TInt reduceablePluginIndex = FindReduceablePlugin(overRunHeight,aIndex) ;
+ if (reduceablePluginIndex == -1)
+ {
+ // no plugin can be reduced.
+ // get the plugin with the lowerest Weight and hide it
+ TInt hideblePluginIndex = FindLowerWeightPlugin(aIndex) ;
+ if ((hideblePluginIndex == -1) || (hideblePluginIndex == aIndex))
+ {
+ HidePlugin(aIndex) ;
+ return ;
+ }
+ else
+ {
+ TInt hideblePluginHeight = iPlugins[hideblePluginIndex]->iPlugin->Rect().Size().iHeight ;
+ // Hide the found plugin and move the other before the current
+ ReducePlugin(hideblePluginIndex,aIndex,hideblePluginHeight) ;
+ if (iPlugins[hideblePluginIndex]->iAlignment == EAITop)
+ {
+ // recalculate position the the top current plugin
+ aTopPluginX -= hideblePluginHeight ;
+ }
+ else
+ {
+ // recalculate position the the bottom current plugin
+ aBottomPluginX += hideblePluginHeight;
+ }
+ overRunHeight -= hideblePluginHeight;
+ }
+ }
+ else
+ {
+ // get the height that the found reduaceble plugin can reduce itself
+ TInt reduceablePluginHeight = iPlugins[reduceablePluginIndex]->iPlugin->GetNextSizeDecrement().iHeight ;
+ if (reduceablePluginIndex == aIndex)
+ {
+ // if it has to be reduced the current plugin
+ // just recalculate the size of itself
+ plugSize -= TSize(0,reduceablePluginHeight) ;
+ if (plugSize.iHeight <= 0)
+ {
+ HidePlugin(aIndex) ;
+ return ;
+ }
+ else
+ {
+ if (pluginItem->iAlignment == EAITop)
+ {
+ rectPlugin.SetRect(TPoint(0,aTopPluginX),plugSize) ;
+ }
+ else
+ {
+ rectPlugin.SetRect(TPoint(0,aBottomPluginX-plugSize.iHeight),plugSize) ;
+ }
+
+ pluginItem->iPlugin->SetRect(rectPlugin);
+ }
+ }
+ else
+ {
+ // reduce the found plugin and move the other before the current
+ ReducePlugin(reduceablePluginIndex,aIndex,reduceablePluginHeight) ;
+ if (iPlugins[reduceablePluginIndex]->iAlignment == EAITop)
+ {
+ // recalculate position the the top current plugin
+ aTopPluginX -= reduceablePluginHeight ;
+ }
+ else
+ {
+ // recalculate position the the bottom current plugin
+ aBottomPluginX += reduceablePluginHeight;
+ }
+ }
+ overRunHeight -= reduceablePluginHeight;
+ }
+ }
+
+ if (overRunHeight > 0)
+ {
+ //no plugin can be reduced go to the next one
+ return;
+ }
+ } // while finding reduceable plugin(s)
+
+ if (pluginItem->iAlignment == EAITop)
+ {
+ rectPlugin.SetRect(TPoint(0,aTopPluginX),plugSize) ;
+ aTopPluginX += plugSize.iHeight;
+ }
+ else
+ {
+ rectPlugin.SetRect(TPoint(0,aBottomPluginX-plugSize.iHeight),plugSize) ;
+ aBottomPluginX -= plugSize.iHeight;
+ }
+ pluginItem->iPlugin->SetRect(rectPlugin);
+ //pluginItem->iPlugin->SetDimmed(EFalse);
+ }
+ else
+ {
+ // No on the screen
+ HidePlugin(aIndex) ;
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::NextVisiblePlugin
+// ---------------------------------------------------------
+//
+TInt CAIPluginContainerControl::NextVisiblePlugin(TInt aStartIndex)
+ {
+ for ( TInt index = aStartIndex; index < iPlugins.Count(); index++)
+ {
+ TPluginInfo* plug = iPlugins[index];
+ if (plug->iPlugin && (plug->iOnScreen) && (plug->iPlugin->IsNonFocusing() == EFalse))
+ {
+ return index ;
+ }
+ }
+ return aStartIndex > 0 ? NextVisiblePlugin(0) : -1 ;
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::PreviousVisiblePlugin
+// ---------------------------------------------------------
+//
+TInt CAIPluginContainerControl::PreviousVisiblePlugin(TInt aStartIndex)
+ {
+ for ( TInt index = aStartIndex; index >= 0; index--)
+ {
+ TPluginInfo* plug = iPlugins[index];
+ if (plug->iPlugin && (plug->iOnScreen) && (plug->iPlugin->IsNonFocusing() == EFalse))
+ {
+ return index ;
+ }
+ }
+ return (aStartIndex < (iPlugins.Count()-1)) ? PreviousVisiblePlugin(iPlugins.Count()-1) : -1 ;
+ }
+
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::FindLowerWeightPlugin
+// ---------------------------------------------------------
+//
+TInt CAIPluginContainerControl::FindLowerWeightPlugin(TInt aCurrentIndex)
+ {
+ TInt foundIndex = -1;
+ TInt plugWeight = -1;
+ TInt currentWeight = iPlugins[aCurrentIndex]->iWeight ;
+
+ for ( TInt index = 0 ; index <= iPlugins.Count()-1; index++)
+ {
+ TPluginInfo* plug = iPlugins[index];
+ if ((plug->iOnScreen) && (plug->iWeight<=currentWeight) &&
+ ((foundIndex==-1) || (plug->iWeight<=plugWeight)))
+ {
+ foundIndex = index ;
+ plugWeight = plug->iWeight;
+ }
+ }
+ return foundIndex ;
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::FindReduceablePlugin
+// ---------------------------------------------------------
+//
+TInt CAIPluginContainerControl::FindReduceablePlugin(TInt aOverRunHeight, TInt aCurrentIndex)
+ {
+ TInt foundIndex = -1;
+ TInt plugWeight = -1;
+
+ for ( TInt index = 0 ; index <= iPlugins.Count()-1; index++)
+ {
+ TPluginInfo* plug = iPlugins[index];
+ //When resize I don't check the Weight with the current plugin
+ // before we try to reduce a plugin
+ // if any plugin can be reduced then we have to hide a plugin with a weight less of the current
+ if ((plug->iResizeable) && (plug->iOnScreen)) //&& (plug->iWeight <= currentWeight))
+ {
+ TInt reduceablePluginHeight = iPlugins[index]->iPlugin->GetNextSizeDecrement().iHeight ;
+ if (reduceablePluginHeight > 0)
+ {
+ // the plugin can still be reduced
+ if (index == aCurrentIndex)
+ {
+ if ((plugWeight == -1) || (plug->iWeight <= plugWeight))
+ {
+ foundIndex = index ;
+ plugWeight = plug->iWeight ;
+ }
+ }
+ else
+ {
+ TSize plugMinSize = plug->iPlugin->GetMinSize() ;
+ TSize plugSize = plug->iPlugin->Rect().Size();
+ TInt plugOverRunHeight = plugSize.iHeight-plugMinSize.iHeight;
+ if ((plugOverRunHeight >=aOverRunHeight) &&
+ ((plugWeight == -1) || (plug->iWeight <= plugWeight))) // before I check the weight
+ {
+ foundIndex = index ;
+ plugWeight = plug->iWeight ;
+ }
+ }
+ }
+ }
+ }
+ return foundIndex ;
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::ReducePlugin
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::ReducePlugin(TInt aPluginToBeReducedIndex,
+ TInt aCurrentIndex,
+ TInt aReduceHeight)
+ {
+ TInt startIndex;
+ TInt lastIndex;
+ TInt lastTopPluginIndex ;
+ TInt index;
+
+ TAIPluginAlignment reduceAlign = iPlugins[aPluginToBeReducedIndex]->iAlignment ;
+
+ //find the last top plugin in the list
+ lastTopPluginIndex = -1;
+ for ( index = 0 ; index < iPlugins.Count() ; index++)
+ {
+ if (iPlugins[index]->iAlignment==EAITop)
+ {
+ lastTopPluginIndex = index;
+ }
+ }
+
+ if (reduceAlign == EAITop)
+ {
+ __ASSERT_ALWAYS(aPluginToBeReducedIndex <= lastTopPluginIndex, User::Invariant());
+ startIndex = aPluginToBeReducedIndex;
+ // we don't have to handle the current if is in the top list
+ // otherwise if the current index is in the bottom we handle all the top plugin
+ lastIndex = (aCurrentIndex <= lastTopPluginIndex) ? (aCurrentIndex > aPluginToBeReducedIndex ? aCurrentIndex -1 : aCurrentIndex ): lastTopPluginIndex;
+ }
+ else
+ {
+ // if lastTopPluginIndex==-1 means all the plugin have a botton alignment
+ startIndex = lastTopPluginIndex+1;
+ if (startIndex == aCurrentIndex)
+ {//we don't have to handle the current plugin
+ startIndex++;
+ }
+ __ASSERT_ALWAYS(aPluginToBeReducedIndex >= startIndex, User::Invariant());
+ lastIndex = aPluginToBeReducedIndex;
+ }
+
+ for ( index = startIndex ; index <= lastIndex; index++)
+ {
+ TPluginInfo* plug = iPlugins[index];
+
+ if (plug->iOnScreen && plug->iPlugin)
+ {
+ TRect rectPlugin = plug->iPlugin->Rect() ;
+ if (index == aPluginToBeReducedIndex)
+ {
+ TSize newSize(0, aReduceHeight) ;
+ rectPlugin.Resize(-newSize) ;
+ if (rectPlugin.Height() == 0)
+ {
+ HidePlugin(index) ;
+ }
+ else
+ {
+ if (reduceAlign == EAIBottom)
+ {
+ rectPlugin.Move(0,+aReduceHeight);
+ }
+ plug->iPlugin->SetRect(rectPlugin) ;
+ }
+ }
+ else
+ {
+ if (reduceAlign == EAITop)
+ {
+ rectPlugin.Move(0,-aReduceHeight);
+ plug->iPlugin->SetRect(rectPlugin);
+ }
+ else
+ {
+ rectPlugin.Move(0,+aReduceHeight);
+ plug->iPlugin->SetRect(rectPlugin);
+ }
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// CAIPluginContainerControl::HidePlugin
+// ---------------------------------------------------------
+//
+void CAIPluginContainerControl::HidePlugin(TInt aIndex)
+ {
+ TPluginInfo* plug = iPlugins[aIndex];
+
+ //plug->iPlugin->SetDimmed(ETrue) ;
+ plug->iPlugin->SetRect(TRect(0,0,0,0)) ;
+ plug->iOnScreen = EFalse ;
+
+ if (iIndexPlugin == aIndex)
+ { // the plugin that is going to dissappear have the focus
+ TRAP_IGNORE(ChangeFocusPluginL(EAIFocusDown)); //TRAPPED
+ }
+ }
+
+// End of File