/*
* Copyright (c) 1997-2010 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:
*
*/
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <uikon/eikctrlstatus.h>
#include <uikon/eikenvinterface.h>
#endif
#include <eikcolib.h>
#include <eikappui.h>
#include <eiktbar.h>
#include <eikcoctl.rsg>
#include <eikenv.h>
#include <eikdoc.h>
#include <eiklabel.h>
#include <uikon.hrh>
#include <eikapp.h>
#include <eikmenub.h>
#include <eikhkeyt.h>
#include <eikhkeyc.h>
#include <eikpanic.h>
#include <eikcmbut.h>
#include <eiksfont.h>
#include <eikedwin.h>
#include <eikmnbut.h>
#include <eikimage.h>
#include <eiklbbut.h>
#include <eiktxlbx.h>
#include <eikfnlab.h>
#include <eikbtgpc.h>
#include <eikscrlb.h>
#include <uiklaf/private/lafappui.h>
#include "LAFMENUB.H"
#include <eikbtpan.h>
#include <barsread.h>
#include <barsc.h>
#include <eikcba.h>
#include "eikmop.h"
#include <AknSgcc.h>
#include <AknLayout.lag>
#include <eikcoctlpanic.h>
#include <akntoolbar.h>
#include <akntoolbarextension.h>
#include <aknappui.h>
#ifdef RD_SCALABLE_UI_V2
#include <featmgr.h>
#include <bldvariant.hrh>
#include <akntouchpane.h>
#include <AknStatuspaneUtils.h>
#include <aknpriv.rsg>
#endif // RD_SCALABLE_UI_V2
#include <layoutmetadata.cdl.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <AknPriv.hrh>
#include <aknlayout.cdl.h>
// Static DLL functions
GLDEF_C void Panic(TEikPanic aPanic)
{
_LIT(KPanicCat,"EIKCOCTL");
User::Panic(KPanicCat,aPanic);
}
GLDEF_C void Panic(TEikCoCtlPanic aPanic)
{
_LIT(KPanicCat,"AVKON-EIKCOCTL");
User::Panic(KPanicCat,aPanic);
}
///////////////////////////////////////////////////////////////////////////////////////
//
// CEikAppUiFactoryExtension
//
///////////////////////////////////////////////////////////////////////////////////////
class CEikAppUiFactoryExtension : public CBase
{
public:
static CEikAppUiFactoryExtension* NewL();
void ReadAppInfoResourceExtensionL( TInt aResourceId );
~CEikAppUiFactoryExtension();
void CreateDefaultToolbarL();
private:
CEikAppUiFactoryExtension();
void ConstructL();
public:
CEikButtonGroupContainer* iCba;
CAknTouchPane* iTouchPane;
CAknToolbar* iPopupToolbar;
CAknToolbar* iViewPopupToolbar; // not owned
CAknToolbar* iFixedToolbar;
CAknToolbar* iViewFixedToolbar; // not owned
TBool iSplitInput;
};
CEikAppUiFactoryExtension* CEikAppUiFactoryExtension::NewL()
{
CEikAppUiFactoryExtension* self = new(ELeave) CEikAppUiFactoryExtension;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
CEikAppUiFactoryExtension::~CEikAppUiFactoryExtension()
{
delete iCba;
#ifdef RD_SCALABLE_UI_V2
delete iTouchPane;
delete iFixedToolbar;
#endif // RD_SCALABLE_UI_V2
delete iPopupToolbar;
}
CEikAppUiFactoryExtension::CEikAppUiFactoryExtension()
{
iSplitInput = EFalse;
}
void CEikAppUiFactoryExtension::ConstructL()
{
}
void CEikAppUiFactoryExtension::ReadAppInfoResourceExtensionL( TInt aExtResourceId )
{
struct SEikAppInfoExtension
{
TInt iTouchPaneId;
TInt iPopupToolbarId;
TInt iSpare1Id;
TInt iSpare2Id;
} appInfoExt;
TPtr8 ptr( ( TText8* )&appInfoExt, sizeof( appInfoExt ) );
// set all members of appInfo to zero, in case of ignored
// leave during resource reading
ptr.FillZ(ptr.MaxLength());
// if application resource structure has extension
if ( aExtResourceId )
{
CCoeEnv::Static()->ReadResourceAsDes8L( ptr, aExtResourceId );
}
#ifdef RD_SCALABLE_UI_V2
FeatureManager::InitializeLibL();
if ( FeatureManager::FeatureSupported( KFeatureIdPenSupport ) )
{
delete iTouchPane; iTouchPane = NULL;
if ( appInfoExt.iTouchPaneId )
{
iTouchPane = CAknTouchPane::NewL( appInfoExt.iTouchPaneId );
}
else
{
iTouchPane = CAknTouchPane::NewL();
}
}
FeatureManager::UnInitializeLib();
#endif // RD_SCALABLE_UI_V2
if ( appInfoExt.iPopupToolbarId )
{
if ( iPopupToolbar )
{
delete iPopupToolbar;
iPopupToolbar = NULL;
}
iPopupToolbar = CAknToolbar::NewL( appInfoExt.iPopupToolbarId );
CEikonEnv* eikEnv = CEikonEnv::Static();
CAknAppUi* base = (CAknAppUi*)eikEnv->EikAppUi();
if (base)
{
iPopupToolbar->SetMopParent(base);
}
#ifdef RD_SCALABLE_UI_V2
if ( iPopupToolbar->ToolbarFlags() & KAknToolbarFixed )
{
iFixedToolbar = iPopupToolbar;
iPopupToolbar = NULL;
}
if ( iTouchPane )
{
iPopupToolbar->SetObserver( iTouchPane );
}
#endif // RD_SCALABLE_UI_V2
}
if ( !iFixedToolbar )
{
CreateDefaultToolbarL();
}
}
void CEikAppUiFactoryExtension::CreateDefaultToolbarL()
{
if ( !iFixedToolbar )
{
iFixedToolbar = CAknToolbar::NewL( R_AKNPRIV_TOOLBAR );
CEikonEnv* eikEnv = CEikonEnv::Static();
CAknAppUi* base = (CAknAppUi*)eikEnv->EikAppUi();
if (base)
{
iFixedToolbar->SetMopParent(base);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////
//
// CEikCoCtlLibrary
//
///////////////////////////////////////////////////////////////////////////////////////
CEikCoCtlLibrary::CEikCoCtlLibrary()
{
}
///////////////////////////////////////////////////////////////////////////////////////
//
// ResourceFile
//
///////////////////////////////////////////////////////////////////////////////////////
EXPORT_C TFileName CEikCoCtlLibrary::ResourceFile()
{
_LIT(KResFileName,"z:\\resource\\eikcoctl.rsc");
return KResFileName();
}
///////////////////////////////////////////////////////////////////////////////////////
//
// ControlFactory
//
///////////////////////////////////////////////////////////////////////////////////////
EXPORT_C TCreateByTypeFunction CEikCoCtlLibrary::ControlFactory()
{
return CreateByTypeL;
}
/**
* @internal
* Internal to Symbian
* @since App-Framework_6.1
*/
EXPORT_C TCreateButtonGroupByTypeFunction CEikCoCtlLibrary::ButtonGroupFactory()
{//static
return CreateButtonGroupByTypeL;
}
///////////////////////////////////////////////////////////////////////////////////////
//
// CreateByTypeL
//
///////////////////////////////////////////////////////////////////////////////////////
SEikControlInfo CEikCoCtlLibrary::CreateByTypeL(TInt aControlType)
{
SEikControlInfo controlInfo;
controlInfo.iControl = NULL;
controlInfo.iTrailerTextId = 0;
controlInfo.iFlags = 0;
switch (aControlType)
{
case EEikCtEdwin:
controlInfo.iControl = new(ELeave) CEikEdwin;
break;
case EEikCtListBox:
controlInfo.iControl = new(ELeave) CEikTextListBox;
break;
case EEikCtLabel:
controlInfo.iControl = new(ELeave) CEikLabel;
controlInfo.iFlags = EEikControlIsNonFocusing|EEikControlHasExtraAscent;
break;
case EEikCtImage:
controlInfo.iControl = new(ELeave) CEikImage;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtCommandButton:
controlInfo.iControl= new(ELeave) CEikCommandButton;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtFileNameLabel:
controlInfo.iControl = new(ELeave) CEikFileNameLabel;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtMenuButton:
controlInfo.iControl= new(ELeave) CEikMenuButton;
break;
case EEikCtTextButton:
controlInfo.iControl= new(ELeave) CEikTextButton;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtBitmapButton:
controlInfo.iControl= new(ELeave) CEikBitmapButton;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtLabeledButton:
controlInfo.iControl = new(ELeave) CEikLabeledButton;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtTwoPictureCommandButton:
controlInfo.iControl= new(ELeave) CEikTwoPictureCommandButton;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtInverterCommandButton:
controlInfo.iControl= new(ELeave) CEikInverterCommandButton;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EEikCtScrollBar:
controlInfo.iControl = new(ELeave) CEikScrollBar;
controlInfo.iFlags = EEikControlIsNonFocusing;
break;
case EAknCtToolbarExtension:
controlInfo.iControl = CAknToolbarExtension::NewL();
break;
default:
break;
}
return controlInfo;
}
/**
* Creates the button group identified by aButtonGroupType, if it exists in this button
* group factory. Extra required information is supplied in aCreationData. If the button group
* is to be added to the button group stack then this can be set in aAddToButtonGroupStack.
* If the aButtonGroupType value does not exist, then it returns NULL.
*
* @internal
* Internal to Symbian
* @since App-Framework_6.1
*/
MEikButtonGroup* CEikCoCtlLibrary::CreateButtonGroupByTypeL(TInt aButtonGroupType,EikButtonGroupFactory::TCreationData& aCreationData,TBool& aAddToButtonGroupStack)
{//static
MEikButtonGroup* buttonGroup = NULL;
switch (aButtonGroupType)
{
case EEikBgToolBar:
{
CEikToolBar* toolBar=new(ELeave) CEikToolBar;
CleanupStack::PushL(toolBar);
TRect rect(CCoeEnv::Static()->ScreenDevice()->SizeInPixels());
toolBar->ConstructL(aCreationData.iCommandObserver,aCreationData.iResourceId,rect);
CleanupStack::Pop(); // toolBar
buttonGroup = toolBar;
}
break;
case EEikBgButtonPanel:
{
CEikButtonPanel* buttonPanel=new(ELeave) CEikButtonPanel;
CleanupStack::PushL(buttonPanel);
CEikButtonGroupContainer* container = static_cast<CEikButtonGroupContainer*>(aCreationData.iCommandObserver);
buttonPanel->SetContainerWindowL(*container);
buttonPanel->SetCommandObserver(aCreationData.iCommandObserver);
if (aCreationData.iResourceId==0)
buttonPanel->ConstructL();
else
{
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC(reader,aCreationData.iResourceId);
buttonPanel->ConstructFromResourceL(reader);
CleanupStack::PopAndDestroy(); // reader
}
if (aCreationData.iOrientation==CEikButtonGroupContainer::EHorizontal)
buttonPanel->SetHorizontal();
CleanupStack::Pop(); // buttonPanel
buttonGroup = buttonPanel;
}
break;
case EEikBgCba:
{
buttonGroup = CEikCba::NewLC(aCreationData.iResourceId, NULL,
aCreationData.iCommandObserver, aCreationData.iParentWg,
aCreationData.iFlags);
CleanupStack::Pop(); // cba
aAddToButtonGroupStack=ETrue;
}
break;
default:
break;
}
return buttonGroup;
}
/**
* @internal
*/
EXPORT_C CEikAppUiFactory::CEikAppUiFactory()
: iSidebarPopupId(-1)
{
}
/**
* @internal
*/
CEikAppUiFactory::~CEikAppUiFactory()
{
CCoeAppUi* appUi = CEikonEnv::Static()->EikAppUi();
if ( appUi )
appUi->RemoveFromStack(iMenuBar);
delete(iMenuBar);
delete(iToolBar);
delete(iToolBand);
delete(iTitleBand);
delete(iStatusPane);
delete(iExtension);
}
CEikCommandButton* CEikAppUiFactory::CreateStandardTabButtonL() const
{
CEikCommandButton *tabButton= new(ELeave) CEikCommandButton;
CleanupStack::PushL(tabButton);
TBuf<1> buf;
buf.Append(TChar(ESymFontTabout));
tabButton->SetTextL(buf);
tabButton->Label()->SetFont(CEikonEnv::Static()->SymbolFont());
const TInt height = CEikonEnv::Static()->EditableControlStandardHeight();
tabButton->SetSize(TSize(height+3,height));
CleanupStack::Pop();
return(tabButton);
}
void CEikAppUiFactory::CreateEmbeddedL(CEikonEnv& aEikonEnv)
{
CEikAppUiFactory* embeddedAppUiFactory = new(ELeave) CEikAppUiFactory();
CleanupStack::PushL(embeddedAppUiFactory);
aEikonEnv.AddAppUiFactoryL(embeddedAppUiFactory);
CleanupStack::Pop();
}
void CEikAppUiFactory::DestroyEmbedded(CEikonEnv& aEikonEnv)
{
aEikonEnv.RemoveAppUiFactory();
delete this;
}
void CEikAppUiFactory::CreateResourceIndependentFurnitureL(CEikAppUi* aAppUi)
{
#ifdef RD_SCALABLE_UI_V2
FeatureManager::InitializeLibL();
if ( FeatureManager::FeatureSupported( KFeatureIdPenSupport ) )
{
if ( !iExtension )
{
iExtension = CEikAppUiFactoryExtension::NewL();
}
if ( iExtension && !( iExtension->iTouchPane ) )
{
iExtension->iTouchPane = CAknTouchPane::NewL();
}
if ( iExtension )
{
iExtension->CreateDefaultToolbarL();
}
}
FeatureManager::UnInitializeLib();
#endif // RD_SCALABLE_UI_V2
if(aAppUi->ContainerAppUi())
{
AddTitleBandL(aAppUi);
}
CEikonEnv* eikEnv = CEikonEnv::Static();
if (eikEnv->StatusPaneCoreResId() != 0)
{
iStatusPane = CEikStatusPane::NewL(*eikEnv, &eikEnv->RootWin(), eikEnv->StatusPaneCoreResId(), EEikStatusPaneUseDefaults);
CAknSgcClient::HandleChangeL(); // has to be called after iStatusPane is assigned
}
}
void CEikAppUiFactory::AddTitleBandL(CEikAppUi* /*aAppUi*/)
{
/* AKNLAF - Series 60 does not require a title band for embedded apps
iTitleBand=new(ELeave) CEikToolBar;
iTitleBand->StaticConstructL(aAppUi,R_EIK_TBAR_TITLE);
TBuf<64> tmp;
const TApaAppCaption& object=aAppUi->Document()->AppCaption();
const TApaAppCaption& container=aAppUi->ContainerAppUi()->Document()->AppCaption();
CCoeEnv::Static()->Format128(tmp,R_EIK_TBUF_TITLE_BAR_LABEL,&object,&container);
STATIC_CAST(CEikLabel*,iTitleBand->ControlById(EEikCidTitleBarLabel))->SetTextL(tmp);
CCoeControl* ctrl=iTitleBand->ControlById(EEikCidTitleBatFileNameLabel);
if (ctrl)
{
const TInt index=iTitleBand->IndexById(EEikCidTitleBatFileNameLabel);
CArrayFix<TEikGroupControl>* ctrlArray=iTitleBand->ControlArray();
if (index==ctrlArray->Count()-1)
{
const TInt width=(iToolBar ? iToolBar->Size().iWidth : KEikStdFileNameLabelWidth);
(*ctrlArray)[index].SetLength(width);
STATIC_CAST(CEikFileNameLabel*,iTitleBand->ControlById(EEikCidTitleBatFileNameLabel))->UpdateL();
}
}
const TRect rect(aAppUi->ApplicationRect());
iTitleBand->SetBoundingRect(rect);
if (!(iTitleBand->DelayActivation()))
iTitleBand->ActivateL();
*/
}
TRect CEikAppUiFactory::ClientRect()
{
CCoeEnv* env = CCoeEnv::Static();
TRect rect = LafAppUi::ClientRect( *env, *this );
CAknToolbar* toolbar = CurrentFixedToolbar();
// Reduce fixed toolbar's area.
if ( toolbar )
{
TInt flags = toolbar->ToolbarFlags();
if ( flags & KAknToolbarFixed && !( flags & KAknToolbarDefault ) )
{
toolbar->ReduceRect( rect );
}
}
// Recalculate the client rect is split input is enabled.
if ( iExtension && iExtension->iSplitInput )
{
TInt inputTop = rect.iBr.iY;
TAknLayoutRect splitwnd;
TRect screenRect ;
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );
if ( Layout_Meta_Data::IsLandscapeOrientation() )
{
splitwnd.LayoutRect(
screenRect,
AknLayoutScalable_Avkon::popup_fep_vkbss_window( 0 ).LayoutLine() );
}
else
{
splitwnd.LayoutRect(
screenRect,
AknLayoutScalable_Avkon::popup_fep_ituss_window( 0 ).LayoutLine() );
}
TRect wndRc( splitwnd.Rect() );
inputTop = wndRc.iTl.iY;
rect.iBr.iY = rect.iBr.iY > inputTop ? inputTop : rect.iBr.iY;
rect.iTl.iY = 0;
}
return rect;
}
void CEikAppUiFactory::ReadAppInfoResourceL(TInt aResourceFileOffset, CEikAppUi* aAppUi)
{
const TInt resourceFileOffset=(aResourceFileOffset)? aResourceFileOffset : aAppUi->Application()->ResourceFileOffset();
SEikAppInfo appInfo;
TPtr8 ptr((TText8*)&appInfo,sizeof(appInfo));
ptr.FillZ(ptr.MaxLength()); // set all members of appInfo to zero, in case of ignored leave during resource reading
CCoeEnv::Static()->ReadResourceAsDes8L(ptr,EAppInfoResourceOffset+resourceFileOffset);
if (!iExtension)
{
iExtension = CEikAppUiFactoryExtension::NewL();
}
iExtension->ReadAppInfoResourceExtensionL(appInfo.iExtensionId);
if (appInfo.iMenuBarId)
{
iMenuBar=new(ELeave) CEikMenuBar;
iMenuBar->ConstructL(aAppUi,appInfo.iHotKeysId,appInfo.iMenuBarId);
aAppUi->AddToStackL(iMenuBar,ECoeStackPriorityMenu,ECoeStackFlagRefusesFocus);
if (LafMenuBar::IsAlwaysVisible())
{
iMenuBar->TryDisplayMenuBarL();
}
}
TRect boundingRect=ClientRect(); // make toolband stretch to the screen width by default
// !!! Toolbar / CBA decision should be made in the LAF.
CEikonEnv* eikEnv = CEikonEnv::Static();
if (eikEnv->StatusPaneCoreResId() != 0)
{
iStatusPane = CEikStatusPane::NewL(*eikEnv, &eikEnv->RootWin(), eikEnv->StatusPaneCoreResId(), appInfo.iStatusPaneId);
CAknSgcClient::HandleChangeL(); // has to be called after iStatusPane is assigned
iStatusPane->ReduceRect(boundingRect);
#ifdef RD_SCALABLE_UI_V2
// Hide touch pane when compatible statuspane is no active
if ( TouchPane() && !AknStatuspaneUtils::TouchPaneCompatibleLayoutActive() )
{
TouchPane()->MakeVisible( EFalse );
}
#endif // RD_SCALABLE_UI_V2
#ifdef RD_SCALABLE_UI_V2
// Hide toolbar when compatible statuspane is not active
if ( iExtension->iFixedToolbar && ( !AknStatuspaneUtils::TouchPaneCompatibleLayoutActive() ||
appInfo.iStatusPaneId == R_AVKON_STATUS_PANE_LAYOUT_EMPTY ) )
{
iExtension->iFixedToolbar->SetToolbarVisibility( EFalse );
}
#endif // RD_SCALABLE_UI_V2
}
if (appInfo.iCbaId)
{
iExtension->iCba = CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::ECba,
CEikButtonGroupContainer::EHorizontal/*LafCba::Orientation()*/, aAppUi,appInfo.iCbaId);
iExtension->iCba->SetBoundingRect(boundingRect);
iExtension->iCba->ReduceRect(boundingRect);
// iToolBar=CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::ECba,
// CEikButtonGroupContainer::EVertical,
// aAppUi,appInfo.iCbaId);
// iToolBar->SetBoundingRect(boundingRect);
}
if (appInfo.iToolBarId)
{
iToolBar=CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::EToolbar,CEikButtonGroupContainer::EVertical,
aAppUi,appInfo.iToolBarId);
iToolBar->SetBoundingRect(boundingRect);
}
if (aAppUi->ContainerAppUi())
AddTitleBandL(aAppUi);
if (appInfo.iToolBandId)
{
boundingRect.iTl.iY=ClientRect().iTl.iY;
iToolBand=new(ELeave) CEikToolBar;
iToolBand->StaticConstructL(aAppUi,appInfo.iToolBandId);
if (iTitleBand)
iToolBand->SetAdjacent(EGulAdjTop);
iToolBand->SetBoundingRect(boundingRect);
if (!iToolBand->DelayActivation())
iToolBand->ActivateL();
if (iToolBar) // in case toolbar/band overlap, put bar in front
iToolBar->DrawableWindow()->SetOrdinalPosition(0);
}
if (iTitleBand) // put title band in front
iTitleBand->DrawableWindow()->SetOrdinalPosition(0);
}
void CEikAppUiFactory::LaunchPopupMenuL(
TInt aResourceId,
const TPoint& aTargetPos,
TPopupTargetPosType aTargetType,
const CEikHotKeyTable* aHotKeyTable,
CEikAppUi* aAppUi)
{
ClosePopup(aAppUi);
iPopup=new(ELeave) CEikMenuPane(aAppUi);
TRAPD(err,DoLaunchPopupL(aResourceId,aTargetPos,aHotKeyTable,aTargetType, aAppUi));
if (err)
{
ClosePopup(aAppUi);
User::Leave(err);
}
}
void CEikAppUiFactory::DoLaunchPopupL(TInt aResourceId,
const TPoint& aTargetPos,
const CEikHotKeyTable* aHotKeyTable,
TPopupTargetPosType aTargetType,
CEikAppUi* aAppUi)
{
iPopup->ConstructL(NULL);
aAppUi->RestoreMenuL(iPopup,aResourceId,MEikMenuObserver::EMenuPane);
iPopup->SetPointerCapture(ETrue);
aAppUi->AddToStackL(iPopup,ECoeStackPriorityDialog);
iPopup->StartDisplayingMenuPane(aHotKeyTable,aTargetPos,NULL,0,aTargetType);
}
void CEikAppUiFactory::ClosePopup(CEikAppUi* aAppUi)
{
if (iPopup)
{
aAppUi->RemoveFromStack(iPopup);
delete(iPopup);
iPopup=NULL;
}
iSidebarPopupId=-1;
}
void CEikAppUiFactory::StopDisplayingMenuBar()
{
if (iMenuBar)
iMenuBar->StopDisplayingMenuBar();
}
void CEikAppUiFactory::HandleSideBarMenuL(
TInt aResourceId,
const TPoint& aPos,
const CEikHotKeyTable* aHotKeyTable,
CEikAppUi* aAppUi)
{
TBool launchSidebarPopup(iSidebarPopupId!=aResourceId && (aResourceId==R_EIK_SIDEBAR_EDIT_MENU || aResourceId==R_EIK_SIDEBAR_IRDA_MENU));
if (iPopup)
ClosePopup(aAppUi);// sets iSidebarPopupId to -1
if (aResourceId==0) // 0 indicates menu bar
{
iMenuBar->TryDisplayMenuBarL();
const TInt title=iMenuBar->SelectedTitle();
const TInt item=iMenuBar->SelectedItem();
iMenuBar->MoveHighlightToL(title, (item>=0?item:0));
return;
}
// otherwise a popup menu
if (iMenuBar)
iMenuBar->StopDisplayingMenuBar();
if (launchSidebarPopup)
{
LaunchPopupMenuL(aResourceId,aPos,EPopupTargetTopLeft,aHotKeyTable, aAppUi);
iSidebarPopupId=aResourceId;
}
}
void CEikAppUiFactory::CreateHotKeyControlL(TInt aResourceId, CEikAppUi* aAppUi)
{
CEikHotKeyTable* table=new(ELeave) CEikHotKeyTable;
CleanupStack::PushL(table);
table->ConstructFromResourceL(aResourceId);
CEikHotKeyControl* control=new(ELeave) CEikHotKeyControl(table,aAppUi);
CleanupStack::Pop(); // table now owned by control
CleanupStack::PushL(control);
aAppUi->AddToStackL(control,ECoeStackPriorityMenu,ECoeStackFlagRefusesFocus|ECoeStackFlagOwnershipTransfered);
CleanupStack::Pop();
}
CEikMenuBar* CEikAppUiFactory::MenuBar() const
{
return iMenuBar;
}
CEikMenuBar* CEikAppUiFactory::SwapMenuBar(CEikMenuBar* aMenu)
{
CEikMenuBar* oldMenu=iMenuBar;
iMenuBar=aMenu;
return oldMenu;
}
CEikMenuPane* CEikAppUiFactory::Popup() const
{
return iPopup;
}
CEikButtonGroupContainer* CEikAppUiFactory::ToolBar() const
{
// return iToolBar;
return (iExtension ? iExtension->iCba : NULL);
}
CEikButtonGroupContainer* CEikAppUiFactory::SwapButtonGroup(CEikButtonGroupContainer* aNewGroup)
{
CEikButtonGroupContainer* old=iToolBar;
iToolBar=aNewGroup;
return old;
}
CEikToolBar* CEikAppUiFactory::ToolBand() const
{
return iToolBand;
}
CEikToolBar* CEikAppUiFactory::TitleBand() const
{
return iTitleBand;
}
CEikStatusPane* CEikAppUiFactory::StatusPane() const
{
return iStatusPane;
}
CEikButtonGroupContainer* CEikAppUiFactory::Cba() const
{
return (iExtension ? iExtension->iCba : NULL);
}
CEikToolBar* CEikAppUiFactory::SwapToolBar(CEikToolBar* aToolBar,TToolBarType aType)
{
CEikToolBar* old=NULL;
if (aType==EBand)
{
old=iToolBand;
iToolBand=aToolBar;
}
else // aType==ETitle
{
old=iTitleBand;
iTitleBand=aToolBar;
}
return old;
}
void CEikAppUiFactory::HandleResourceChangeL(TInt aType)
{
if ( iExtension )
{
if ( aType == KAknSplitInputEnabled )
{
iExtension->iSplitInput = ETrue;
}
else if ( aType == KAknSplitInputDisabled )
{
iExtension->iSplitInput = EFalse;
}
}
if(iStatusPane)
iStatusPane->HandleResourceChange(aType);
if(iExtension && iExtension->iCba)
iExtension->iCba->HandleResourceChange(aType);
if(iMenuBar)
iMenuBar->HandleResourceChange(aType);
if(iToolBar)
iToolBar->HandleResourceChange(aType);
if(iToolBand)
iToolBand->HandleResourceChange(aType);
if(iTitleBand)
iTitleBand->HandleResourceChange(aType);
if(iPopup)
iPopup->HandleResourceChange(aType);
#ifdef RD_SCALABLE_UI_V2
if (TouchPane())
TouchPane()->HandleResourceChange(aType);
#endif // RD_SCALABLE_UI_V2
}
EXPORT_C CAknTouchPane* CEikAppUiFactory::TouchPane() const
{
return (iExtension ? iExtension->iTouchPane : NULL);
}
// -----------------------------------------------------------------------------
// CEikAppUiFactory::PopupToolbar
// Returns the toolbar for the application or NULL.
// -----------------------------------------------------------------------------
//
EXPORT_C CAknToolbar* CEikAppUiFactory::PopupToolbar() const
{
// if there is specific floating toolbar for appui then that will be
// returned, otherwise fixed toolbar or NULL
if ( iExtension )
{
if ( iExtension->iPopupToolbar )
{
return iExtension->iPopupToolbar;
}
else
{
#ifdef RD_SCALABLE_UI_V2
return iExtension->iFixedToolbar;
#else
return NULL;
#endif
}
}
return NULL;
}
// -----------------------------------------------------------------------------
// CEikAppUiFactory::CurrentPopupToolbar
// If current view has toolbar it will return that one, otherwise it will return
// application toolbar or NULL.
// -----------------------------------------------------------------------------
//
EXPORT_C CAknToolbar* CEikAppUiFactory::CurrentPopupToolbar() const
{
// if there is specific toolbar for the view then this one will be returned, otherwise
// application toolbar will be returned.
if (!iExtension)
return NULL;
return iExtension->iViewPopupToolbar ? iExtension->iViewPopupToolbar:
iExtension->iPopupToolbar;
}
// -----------------------------------------------------------------------------
// CEikAppUiFactory::CurrentFixedToolbar
// If current view has fixed toolbar it will return that one, otherwise it will
// return application fixed toolbar or NULL.
// -----------------------------------------------------------------------------
//
EXPORT_C CAknToolbar* CEikAppUiFactory::CurrentFixedToolbar() const
{
// if there is specific toolbar for the view then this one will be returned, otherwise
// application toolbar will be returned.
if (!iExtension)
return NULL;
return iExtension->iViewFixedToolbar ? iExtension->iViewFixedToolbar :
iExtension->iFixedToolbar;
}
// -----------------------------------------------------------------------------
// CEikAppUiFactory::SetViewPopupToolbar
// Sets view specific toolbar when view is activated. Called by CAknView
// -----------------------------------------------------------------------------
//
EXPORT_C void CEikAppUiFactory::SetViewPopupToolbar(CAknToolbar* aViewPopupToolbar)
{
// not sure if we should try to create extension here
if (iExtension)
iExtension->iViewPopupToolbar = aViewPopupToolbar;
}
// -----------------------------------------------------------------------------
// CEikAppUiFactory::SetViewPopupToolbar
// Sets view specific toolbar when view is activated. Called by CAknView
// -----------------------------------------------------------------------------
//
EXPORT_C void CEikAppUiFactory::SetViewFixedToolbar(CAknToolbar* aViewFixedToolbar)
{
// not sure if we should try to create extension here
if (iExtension)
iExtension->iViewFixedToolbar = aViewFixedToolbar;
}
void CEikAppUiFactory::ReduceRect(TScreenFurniture aScreenFurniture,TRect& aRect) const
{
switch (aScreenFurniture)
{
case EMenuBar:
if (iMenuBar)
iMenuBar->ReduceRect(aRect);
break;
case EButtonGroup:
if (iToolBar)
iToolBar->ReduceRect(aRect);
break;
case EToolBand:
if (iToolBand)
iToolBand->ReduceRect(aRect);
break;
case ETitleBand:
if (iTitleBand)
iTitleBand->ReduceRect(aRect);
break;
case EStatusPane:
{
CEikStatusPaneBase* statusPane=CEikStatusPaneBase::Current();
if (statusPane)
statusPane->ReduceRect(aRect);
break;
}
case ECba:
if (iExtension && iExtension->iCba)
iExtension->iCba->ReduceRect(aRect);
break;
default:
break;
}
}
TTypeUid::Ptr CEikAppUiFactory::MopSupplyObject(TTypeUid aId)
{
return SupplyMopObject(aId, (iExtension ? iExtension->iCba : NULL), iMenuBar);
}
//////////////////////////////////////////////////////////////////////////////////////
//
// END OF FILE
//
//////////////////////////////////////////////////////////////////////////////////////