appframe.cpp

在手机操作系统symbina上使用的一个脚本扩展语言的代码实现,可以参考用于自己的开发

// APPFRAME.CPP
//
#include <bldvariant.hrh>

#include <eikon.hrh>
#include <eikenv.h>
#include <w32std.h>

#include <eiktbar.h>
#if defined(__CRYSTAL__)
#include <indicato.rsg>
#include <ckntitle.h>
#if defined(USE_ADDTODESK)
#include <linkbase.h>
#include <linkapplication.h>
#include <linkdocument.h>
#endif
#include <linkutils.h>
#include <cknconf.h> // for CCknConfirmationDialog
#include <ckninfo.h> // for CCknInfoDialog
#endif
#if defined(__UIQ__)
#include <oplr.rsg>
#include <qiktoolbar.h>
#endif
#include <eikspane.h>



#include "opxutil.h"
#include "appframe.h"

COpxAppFrameObserver* COpxAppFrameObserver::NewL(OplAPI& aOplAPI)
	{
	COpxAppFrameObserver* This=new(ELeave) COpxAppFrameObserver();
	CleanupStack::PushL(This);
	This->ConstructL(aOplAPI);
	CleanupStack::Pop(This);
	return This;
	}

void COpxAppFrameObserver::ConstructL(OplAPI& aOplAPI)
	{
	iCallback = new(ELeave) CArrayFixFlat<TProcedureName>(4);
	iOplAPI = &aOplAPI;
	}

COpxAppFrameObserver::COpxAppFrameObserver()
	:MEikCommandObserver()
	{
	}

COpxAppFrameObserver::~COpxAppFrameObserver()
	{
	delete iCallback;
	}

void COpxAppFrameObserver::ProcessCommandL(TInt aCommandId)
	{
	// where aCommandId ranges from 1..4
	TPtrC procedure=iCallback->At(OpxUtil::CppIndex(aCommandId)); //Index starts at 0.
	iOplAPI->InitCallbackL(procedure);
	iOplAPI->PushParamL(TInt32(aCommandId)); //Callback starts at 1.
	User::LeaveIfError(iOplAPI->CallProcedure(EReturnFloat));
	iOplAPI->PopReal64();
	}

void COpxAppFrameObserver::SetMaxCommandsL(TInt aMaxCommands)
	{
	iCallback->ResizeL(aMaxCommands);
	}

void COpxAppFrameObserver::SetCallback(TInt anIndex, TPtrC aCallback)
	{
	iCallback->At(anIndex)=aCallback;
	}

CAppFrameUser* CAppFrameUser::NewL(OplAPI& aOplAPI)
	{
	CAppFrameUser* This=new(ELeave) CAppFrameUser();
	CleanupStack::PushL(This);
	This->ConstructL(aOplAPI);
	CleanupStack::Pop(This);
	return This;
	}

_LIT(KDefaultLabel,"Default");

void CAppFrameUser::ConstructL(OplAPI& aOplAPI)
	{
	// CBA
	iAppFrameObserver = COpxAppFrameObserver::NewL(aOplAPI);
#if defined(__UIQ__)
	const TRect screenRect=CEikonEnv::Static()->EikAppUi()->ClientRect(); // for future usage
	iButtonGroupOwner = new (ELeave) CBaseControl;
	iButtonGroupOwner->ConstructL();
	iButtonGroupContainer = CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::EDialog,
														CEikButtonGroupContainer::EHorizontal,
														iAppFrameObserver,0,*iButtonGroupOwner,
														CEikButtonGroupContainer::EUseMaxSize|CEikButtonGroupContainer::EAddToStack);
	iButtonGroupOwner->iCtrl=iButtonGroupContainer;
	iButtonGroupContainer->SetObserver(iButtonGroupOwner);
#else
	iButtonGroupContainer = CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::ECba,
														CEikButtonGroupContainer::EVertical,
														iAppFrameObserver,NULL);
#endif

#if defined(__UIQ__)
	//!!TODOUIQ - Lars has this as true at construction.
	iButtonGroupContainer->MakeVisible(ETrue); //was false
#else
	iButtonGroupContainer->MakeVisible(EFalse); //was false
#endif

#if defined(__SERIES60__)
	TInt maxCommands=1;
#else
	TInt maxCommands=iButtonGroupContainer->MaxCommands();
#endif
	iAppFrameObserver->SetMaxCommandsL(maxCommands);
#if !defined(__UIQ__)
	for (TInt id=KAfOpxFirstButton; id<=maxCommands; id++)
		iButtonGroupContainer->SetCommandL(id-1,id,KDefaultLabel);
#else
	for (TInt id=KAfOpxFirstButton; id<=maxCommands; id++)
		iButtonGroupContainer->AddCommandL(id-1,id,_L(""));
#endif
	iButtonGroupContainer->DrawableWindow()->SetPointerGrab(EFalse);
	iButtonGroupContainer->ActivateL();

	CEikonEnv& eikonEnv=aOplAPI.EikonEnv(); // cache for speed
#if !defined(__UIQ__)
	const TRect screenRect=eikonEnv.ScreenDevice()->SizeInPixels(); // for future usage
#endif

	TRect boundingRect = screenRect;
	TSize minimumSize=iButtonGroupContainer->MinimumSize();
	boundingRect.iTl.iX=boundingRect.iBr.iX-minimumSize.iWidth;
	iButtonGroupContainer->SetBoundingRect(boundingRect);
#if defined(__UIQ__)
	iButtonGroupOwner->SetSize(TSize(eikonEnv.EikAppUi()->ClientRect().Width(),minimumSize.iHeight));
#endif
#if defined(__CRYSTAL__)
	// Title
	iTitleBar=CCknAppTitle::NewL(); // EEditor is default type
	TRect titleRect;
	titleRect.iTl=TPoint(0,0);
	titleRect.iBr=TPoint(screenRect.Width(),KAfOpxTitleHeight);
	iTitleBar->SetRect(titleRect);
	iTitleBar->SetFocus(ETrue);

	TInt color=0;
	TInt gray=0;
	iTitleWindow=RBackedUpWindow(aOplAPI.WsSession());
	User::LeaveIfError(iTitleWindow.Construct(aOplAPI.RootWindow(),
										aOplAPI.WsSession().GetDefModeMaxNumColors(color,gray),
																		(TUint32)&iTitleWindow));
	iTitleWindow.SetVisible(EFalse);
	TSize size(screenRect.Width(),KAfOpxTitleHeight);
	User::LeaveIfError(iTitleWindow.SetSizeErr(size));
	iTitleWindow.SetPosition(titleRect.iTl);
	User::LeaveIfError(aOplAPI.ScreenDevice()->CreateContext(iTitleContext));
	iTitleContext->Activate(iTitleWindow);
	iTitleWindow.SetOrdinalPosition(0,0);
	iTitleWindow.Activate();

	iTitleBar->CCoeControl::SetContainerWindowL(iTitleWindow);
	iTitleBar->ActivateL();
	ResizeTitleL(eikonEnv);
	iIsTitleBarVisible=EFalse;
	
#if defined(USE_IRLISTEN)
	// Finally, construct our IrListener object (passing a NULL hotkey table)
	iIrListenAppUi=CIrListenAppUi::NewL(KMenuIrListener, NULL);
#endif
#endif
	}

#if defined(__CRYSTAL__)
void CAppFrameUser::InitStatusPane(OplAPI& aOplAPI)
	{
	// Status
	if (iStatusPane)
		return; // already present.
#pragma message("Need to sort out the status pane - default is visible")
	CEikonEnv& eikonEnv=aOplAPI.EikonEnv(); //cache for speed.
	if (eikonEnv.StatusPaneCoreResId() != 0)
		iStatusPane=CEikStatusPane::NewL(eikonEnv,&aOplAPI.RootWindow(),
													eikonEnv.StatusPaneCoreResId(),
													EEikStatusPaneUseDefaults);
#if !defined(__S80_DP2_0__)
	else
		iStatusPane=CEikStatusPane::NewL(eikonEnv,&aOplAPI.RootWindow(),R_INDICATOR);
#endif
	// Make OPLR's status pane sit behind ours, this helps solve some
	// drawing problems
	CEikStatusPane* statusPane = eikonEnv.AppUiFactory()->StatusPane();
	if (statusPane)
		{
		statusPane->SwitchLayoutL(R_INDICATOR_LAYOUT_WIDE);
		statusPane->ApplyCurrentSettingsL();
		statusPane->MakeVisible(EFalse);
		}
	iStatusPane->SwitchLayoutL(R_INDICATOR_LAYOUT_WIDE);
	iStatusPane->ApplyCurrentSettingsL();
	iStatusPane->MakeVisible(EFalse);
	iStatusPaneType=EAfStatusPaneTypeWide;
	}
#else
void CAppFrameUser::InitStatusPane(OplAPI& /*aOplAPI*/)
	{
	// Status
	if (iStatusPane)
		return; // already present.
	}
#endif

TUint CAppFrameUser::MapFromOplMod(TUint aOplMod)
	{
	TUint mod=0;
	if (aOplMod==0)
		return mod;
	if (aOplMod&EOplModAlt)
		mod |= EModifierLeftAlt|EModifierAlt;
	if (aOplMod&EOplModCtrl)
		mod |= EModifierLeftCtrl|EModifierCtrl;
	if (aOplMod&EOplModShift)
		mod |= EModifierLeftShift|EModifierShift;
	if (aOplMod&EOplModCapsLock)
		mod |= EModifierCapsLock;
	if (aOplMod&EOplModFunc)
		mod |= EModifierLeftFunc|EModifierFunc;
	return mod;
	}

/**
 * Processes the OPL procedure
 * AfOfferEvent%:
 * Allows the OPX to handle an event received by the app.
 * Returns KTrue% if event consumed.
 */
void CAppFrameUser::OfferEvent(OplAPI& aOplAPI)
	{
	/*TUint ev7 =*/ aOplAPI.PopInt32(); // y coord -- not used yet, but ready for pen-based Crystal device.
	/*TUint ev6 =*/ aOplAPI.PopInt32(); // x coord -- "
	TUint ev5 = aOplAPI.PopInt32(); //repeat.
	TUint ev4 = aOplAPI.PopInt32(); //modifier
	TUint ev3 = aOplAPI.PopInt32(); //scan
	TUint ev1 = aOplAPI.PopInt32(); //type
	TBool wasConsumed = EFalse;
	if (iButtonGroupContainer)
		{
		if (!(ev1 & ENotKeyMask))
			{
			TKeyEvent keyEvent;
			keyEvent.iCode		= ev1;
			keyEvent.iScanCode	= ev3;
			keyEvent.iModifiers	= MapFromOplMod(ev4);
			keyEvent.iRepeats	= ev5;
			// First check that if iCode was EKeyEnter then iScanCode was EStdKeyEnter.
			// This prevents Ctrl+(Shift)+(Alt)+M being processed as <Enter> which would
			// happen otherwise (thus preventing OPL authors using them as hotkeys)
			if ((keyEvent.iCode==EKeyEnter) && (keyEvent.iScanCode!=EStdKeyEnter))
				wasConsumed=EFalse;
			else
				wasConsumed=iButtonGroupContainer->OfferKeyEventL(keyEvent,EEventKey);
			}
		}
	aOplAPI.Push(OpxUtil::OplBool16(wasConsumed));
	}

/**
 * Processes the OPL procedure
 * AfSetCBAButton:(aButtonPosition%,aText$,aBitmap&,aMask&,aCallback$)
 */
void CAppFrameUser::SetCBAButton(OplAPI& aOplAPI)
	{
	TPtrC callback	= aOplAPI.PopString();
	TInt16 maskId	= aOplAPI.PopInt16();
	TInt16 bitmapId	= aOplAPI.PopInt16();
	TPtrC text	= aOplAPI.PopString();
	TInt buttonPosition = aOplAPI.PopInt16();
	if (callback.Length()==0)
		User::Leave(KOplErrInvalidArgs);
	if (iButtonGroupContainer)
		{
		if (buttonPosition<KAfOpxFirstButton || buttonPosition>iButtonGroupContainer->MaxCommands())
			User::Leave(KOplErrInvalidArgs);
		const TInt containerLocation=buttonPosition-1;
		if (bitmapId>0)
			{
			TInt bitmapHandle = aOplAPI.BitmapHandleFromIdL(bitmapId);
			TInt maskHandle = aOplAPI.BitmapHandleFromIdL(maskId);

#if defined(__UIQ__)
			if(buttonPosition<iButtonGroupContainer->ButtonCount())
				iButtonGroupContainer->SetCommandL(containerLocation,buttonPosition,text,bitmapHandle,maskHandle);
			else
				iButtonGroupContainer->AddCommandL(containerLocation,buttonPosition,text,bitmapHandle,maskHandle);
			}
		else
			{
			if(buttonPosition<iButtonGroupContainer->ButtonCount())
				iButtonGroupContainer->SetCommandL(containerLocation,buttonPosition,text);
			else
				iButtonGroupContainer->AddCommandL(containerLocation,buttonPosition,text);
			}
#else
			iButtonGroupContainer->SetCommandL(containerLocation,buttonPosition,text,bitmapHandle,maskHandle);
			}
		else
			{
			iButtonGroupContainer->SetCommandL(containerLocation,buttonPosition,text);
			}
#endif
#if defined(__UIQ__)
		iButtonGroupContainer->SetSize(iButtonGroupContainer->Size());
#endif
		iButtonGroupContainer->DrawNow();
		iAppFrameObserver->SetCallback(OpxUtil::CppIndex(buttonPosition),callback); //Index from 0..3
		}
	aOplAPI.Push(0.0);
	}

/**
 * Processes the OPL procedure:
 * AfSetCBAButtonDefault:(aButtonPosition%)
 * Sets the CBA button to be default. Only one button may be default at a time.
 */
void CAppFrameUser::SetCBAButtonDefault(OplAPI& aOplAPI)
	{
	TInt buttonPosition=aOplAPI.PopInt16();//aButtonPosition%
	if (iButtonGroupContainer)
		{
		if (buttonPosition<KAfOpxFirstButton || buttonPosition>iButtonGroupContainer->ButtonCount())
			User::Leave(KOplErrInvalidArgs);
		iButtonGroupContainer->SetDefaultCommand(buttonPosition); //CommandId
#if defined(__UIQ__)
		iButtonGroupContainer->SetSize(iButtonGroupContainer->Size());
#endif
		iButtonGroupContainer->DrawNow();
		}
	aOplAPI.Push(0.0);
	}

/**
 * Processes the OPL procedure
 * AfSetCBAButtonDimmed:(aButtonPosition%,aDimmed%)
 * Makes the CBA button dimmed/undimmed, depending on the flag passed in.
 */
void CAppFrameUser::SetCBAButtonDimmed(OplAPI& aOplAPI)
	{
	TBool dimmed=OpxUtil::CppBool(aOplAPI.PopInt16()); //aDimmed%
	TInt buttonPosition=aOplAPI.PopInt16(); //aButtonPosition%
	if (iButtonGroupContainer)
		{
		if (buttonPosition<KAfOpxFirstButton || buttonPosition>iButtonGroupContainer->ButtonCount())
			User::Leave(KOplErrInvalidArgs);
		iButtonGroupContainer->DimCommand(buttonPosition,dimmed); //CommandId
		iButtonGroupContainer->DrawNow();
		}
	aOplAPI.Push(0.0);
	}

/**
 * Processes the OPL procedure
 * AfCBAButtonDimmed%:(aButtonPosition%)
 * Returns 1 if the CBA button is dimmed, otherwise 0.
 */
void CAppFrameUser::CBAButtonDimmed(OplAPI& aOplAPI)
	{
	TInt buttonPosition=aOplAPI.PopInt16();//aButtonPosition%
	if (iButtonGroupContainer)
		{
		if (buttonPosition<KAfOpxFirstButton || buttonPosition>iButtonGroupContainer->ButtonCount())
			User::Leave(KOplErrInvalidArgs);
		aOplAPI.Push(OpxUtil::OplBool16(iButtonGroupContainer->IsCommandDimmed(buttonPosition)));
		return;
		}
	aOplAPI.Push(OpxUtil::OplBool16(EFalse));
	}

/**
 * Processes the OPL procedure
 * AfSetCBAButtonVisible:(aButtonPosition%,aVisible%)
 * Makes the CBA button visible/invisible, depending on the flag passed in.
 */
void CAppFrameUser::SetCBAButtonVisible(OplAPI& aOplAPI)
	{
	TBool visible=OpxUtil::CppBool(aOplAPI.PopInt16()); //aVisible%
	TInt buttonPosition=aOplAPI.PopInt16(); //aButtonPosition%
	if (iButtonGroupContainer)
		{
		if (buttonPosition<KAfOpxFirstButton || buttonPosition>iButtonGroupContainer->ButtonCount())
			User::Leave(KOplErrInvalidArgs);
		iButtonGroupContainer->MakeCommandVisible(buttonPosition,visible);
#if defined(__UIQ__)
		iButtonGroupContainer->SetSize(iButtonGroupContainer->Size());
#endif
		iButtonGroupContainer->DrawNow();
		}
	aOplAPI.Push(0.0);
	}

/**
 * Processes the OPL procedure
 * AfCBAButtonVisible%:(aButtonPosition%)
 * Returns KTrue% if the CBA button is visible, otherwise KFalse%
 */
void CAppFrameUser::CBAButtonVisible(OplAPI& aOplAPI)
	{
	TInt buttonPosition=aOplAPI.PopInt16();//aButtonPosition%
	if (iButtonGroupContainer)
		{
		if (buttonPosition<KAfOpxFirstButton || buttonPosition>iButtonGroupContainer->ButtonCount())
			User::Leave(KOplErrInvalidArgs);
		aOplAPI.Push(OpxUtil::OplBool16(iButtonGroupContainer->IsCommandVisible(buttonPosition)));
		return;
		}
	aOplAPI.Push(OpxUtil::OplBool16(EFalse));
	}

/**
 * Processes the OPL procedure:
 * AfCBAMaxButtons%:
 * Returns the maximum number of buttons available in the ButtonGroupContainer.
 */
void CAppFrameUser::CBAMaxButtons(OplAPI& aOplAPI)
	{
	if (iButtonGroupContainer)
		{
		aOplAPI.Push(TInt16(iButtonGroupContainer->MaxCommands()));
		return;
		}
	aOplAPI.Push(TInt16(0));
	}

/**
 * Processes the OPL procedure
 * AfSetCBAVisible%:(aVisibility%)
 * Makes the CBA visible/invisible, depending on the visibility flag passed in.
 * Returns KTrue% if screen size needs changing, otherwise KFalse%
 */
void CAppFrameUser::SetCBAVisible(OplAPI& aOplAPI)
	{
	TBool newVisibility=OpxUtil::CppBool(aOplAPI.PopInt16());//aVisibility%
	if (iButtonGroupContainer)
		{
		TBool currentVisibility=iButtonGroupContainer->IsVisible();
		if (currentVisibility==newVisibility)
			{
			aOplAPI.Push(OpxUtil::OplBool16(KNoRedraw));
			return;
			}
#if defined(__UIQ__)
		iButtonGroupOwner->MakeVisible(newVisibility);
#else
		iButtonGroupContainer->MakeVisible(newVisibility);
#endif
		TBool redraw=ResizeTitleL(aOplAPI.EikonEnv());
		iButtonGroupContainer->DrawNow();
		aOplAPI.Push(OpxUtil::OplBool16(redraw));
		return;
		}
	aOplAPI.Push(OpxUtil::OplBool16(KNoRedraw));
	}

/**
 * Processes the OPL procedure
 * AfCBAVisible%:
 * Returns KTrue% if the whole CBA is visible, otherwise KFalse%
 */
void CAppFrameUser::CBAVisible(OplAPI& aOplAPI)
	{
	if (iButtonGroupContainer)
		{
		aOplAPI.Push(OpxUtil::OplBool16(iButtonGroupContainer->IsVisible()));
		return;
		}
	aOplAPI.Push(OpxUtil::OplBool16(EFalse));
	}

/**
 * Processes the OPL procedure
 * AfSetStatus%:(aType%)
 * Sets the status pane type to one of ...Narrow% or ...Wide%.
 * Returns KTrue% if screen size needs changing, otherwise KFalse%
 */
void CAppFrameUser::SetStatus(OplAPI& aOplAPI)
	{
	TUint16 newType=aOplAPI.PopInt16();//aType%
	InitStatusPane(aOplAPI);
	if (iStatusPane)