diff -r 000000000000 -r f72a12da539e idlehomescreen/exths/src/plugincontainer/caiplugincontainercontrol.cpp --- /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 //feature flags +#include +#include +#include +#include +#include +#include // pub&sub keys and categories for backup and restore +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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(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(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