<!-- locations provided by component -->

			<defineLocation id="HEADER_FILE" domain="cpp" dir="${inc}" 

				file="${instanceName}.h"

				owned="false"

				location="">

			</defineLocation>

			<template location="HEADER_FILE">

#ifndef ${instanceName.toUpperCase()}_H

#define ${instanceName.toUpperCase()}_H

			</template>

			<defineLocation id="HEADER_INCLUDES" baseLocation="HEADER_FILE"

				location="region(Generated Includes)"

				filter="unique-includes"

				>

			</defineLocation>		

			<template location="HEADER_INCLUDES"><![CDATA[

#include <aknappui.h>

]]>			</template>

			<template location="HEADER_INCLUDES"><![CDATA[

#include <eikmenub.h>

]]>			</template>

			<defineLocation id="FORWARD_DECLARATIONS" baseLocation="HEADER_FILE"

				location="region(Generated Forward Declarations)">

			</defineLocation>		

			<template location="FORWARD_DECLARATIONS"/>

			<defineLocation id="CLASS" baseLocation="HEADER_FILE"

				owned="false"

				location="class(${className})">

				<template><![CDATA[

/**

 * @class	${className} ${instanceName}.h

 * @brief The AppUi class handles application-wide aspects of the user interface, including

 *        container management and the default menu, control pane, and status pane.

 */

class ${className} : public CAknAppUi

	{

public: 

	// constructor and destructor

	${className}();

	void ConstructL();

	virtual ~${className}();

public: 

	// from CEikAppUi

	void HandleCommandL( TInt aCommand );

	void HandleResourceChangeL( TInt aType );	

private:

	void InitializeContainersL();

	};

]]>

				</template>

			</defineLocation>

			<template location="CLASS"/>

			<defineLocation id="CLASS_METHODS" baseLocation="CLASS"

				filter="unique-prototypes"

				location="region(Generated Methods)">

				<template><![CDATA[

public: <% contrib.indentAdjust(-1); %>

]]>				</template>

			</defineLocation>

			<template location="CLASS_METHODS"/>

			<defineLocation id="CLASS_IVARS" baseLocation="CLASS"

			location="region(Generated Instance Variables)">

				<template><![CDATA[

private: <% contrib.indentAdjust(-1); %>

]]>				</template>

			</defineLocation>

			<template location="CLASS_IVARS"/>

			<defineLocation id="BASE_CLASS_LIST" baseLocation="CLASS"

				owned="false"

				filter="unique-bases"

				location="bases()">

			</defineLocation>

			<template location="BASE_CLASS_LIST" />

			<defineLocation id="CLASS_OVERRIDES" baseLocation="CLASS"

				owned="false"

				filter="unique-prototypes"

				location="region(Overridden Methods)">

				<template><![CDATA[

protected: <% contrib.indentAdjust(-1); %>

]]>				</template>

			</defineLocation>			

			<template location="CLASS_OVERRIDES"/>

			<defineLocation id="CLASS_USERHANDLERS" baseLocation="CLASS"

				owned="false"

				filter="unique-prototypes"

				location="region(User Handlers)">

				<template><![CDATA[

protected: <% contrib.indentAdjust(-1); %>

]]>				</template>

			</defineLocation>				

			<template location="CLASS_USERHANDLERS"/>

			<template location="HEADER_FILE">

#endif // ${instanceName.toUpperCase()}_H			

			</template>

			<defineLocation id="MAIN_FILE" domain="cpp" dir="${src}" 

				file="${instanceName}.cpp"

				owned="false"

				location="">

			</defineLocation>

			<template location="MAIN_FILE"/>

			<defineLocation id="MAIN_SYSTEM_INCLUDES" baseLocation="MAIN_FILE"

				location="region(Generated System Includes)"

				filter="unique-includes">

				<template><![CDATA[

#include <eikmenub.h>

]]>				</template>

			</defineLocation>

			<template location="MAIN_SYSTEM_INCLUDES" />

			<defineLocation id="MAIN_USER_INCLUDES" baseLocation="MAIN_FILE"

				location="region(Generated User Includes)"

				filter="unique-includes">

				<template><![CDATA[

#include "${instanceName}.h"

]]>				</template>

			</defineLocation>	

			<template location="MAIN_USER_INCLUDES"/>

			<defineLocation id="CONSTANTS" baseLocation="MAIN_FILE"

				location="region(Generated Constants)">

			</defineLocation>

			<template location="CONSTANTS" />

			<defineLocation id="CONSTRUCTOR" baseLocation="MAIN_FILE"

				owned="false"

				location="function(${className}::${className}())">

				<template><![CDATA[

/**

 * Construct the ${className} instance

 */ 

${className}::${className}()

	{

	}

]]>

				</template>			

			</defineLocation>

			<template location="CONSTRUCTOR"/>

			<defineLocation id="CONSTRUCTOR_BODY" baseLocation="CONSTRUCTOR"

				location="region(Generated Contents)">

			</defineLocation>

			<template location="CONSTRUCTOR_BODY"/>

			<defineLocation id="DESTRUCTOR" baseLocation="MAIN_FILE"

				owned="false"

				location="function(${className}::~${className}())">

				<template><![CDATA[

/** 

 * The appui's destructor removes the container from the control

 * stack and destroys it.

 */

${className}::~${className}()

	{

	}

]]>

				</template>			

			</defineLocation>

			<template location="DESTRUCTOR"/>

			<defineLocation id="DESTRUCTOR_BODY" baseLocation="DESTRUCTOR"

				location="region(Generated Contents)">

			</defineLocation>

			<template location="DESTRUCTOR_BODY"/>

			<defineLocation id="CONSTRUCTL_METHOD" baseLocation="MAIN_FILE"

				owned="false"

				location="function(${className}::ConstructL())">

				<template><![CDATA[

/**

 * @brief Completes the second phase of Symbian object construction. 

 * Put initialization code that could leave here. 

 */ 

void ${className}::ConstructL()

	{

	}

]]>

				</template>			

			</defineLocation>

			<template location="CONSTRUCTL_METHOD"/>

			<defineLocation id="CONSTRUCTL_BODY" baseLocation="CONSTRUCTL_METHOD"

				location="region(Generated Contents)">

			</defineLocation>

			<template id="MakeConstructL" location="CONSTRUCTL_BODY"><![CDATA[

<% var version = getComponentVersions();

if (version.major < 3 || (version.major == 3 && version.minor < 2)) { %>

BaseConstructL(${(properties.skinsSupported ? " EAknEnableSkin " : "")}); 

<% } else { %>

BaseConstructL(${(properties.skinsSupported ? " EAknEnableSkin " : "")}<% %>${(properties.skinsSupported && properties.enableMSK ? " | " : "")}

				${(properties.enableMSK ? " EAknEnableMSK " : "")}); 

<% }

	// In 2.x, this flag is false.  

	// In 2.8, the default is true but may be false.

	// In 3.0, the default is true and must remain so.

if (version.major == 2 && version.minor == 8 && !properties.layoutAware) { %>

SetLayoutAwareApp( false );

<% }

	if (properties.orientation && properties.orientation != "EAppUiOrientationUnspecified") { 

%>SetOrientationL( ${properties.orientation} );

<% }

	var event = instance.events['viewEvent'];

	if (event) { %>

// Enable support for view events. They will be dispatched to ${event.handlerName}()

AddViewObserverL( this );

<% } %>InitializeContainersL();

]]>		</template>

			<defineLocation id="INIT_CONTAINERSL" baseLocation="MAIN_FILE"

				owned="true"

				location="function(${className}::InitializeContainersL())">

				<template><![CDATA[

void ${className}::InitializeContainersL()

	{

	}

]]>				</template>

			</defineLocation>

			<template location="INIT_CONTAINERSL"/>

			<defineLocation id="HANDLECOMMANDL_METHOD" baseLocation="MAIN_FILE"

				owned="false"

				location="function(${className}::HandleCommandL(TInt))">

				<template><![CDATA[

/**

 * Handle a command for this appui (override)

 * @param aCommand command id to be handled

 */

void ${className}::HandleCommandL( TInt aCommand )

	{

	}

]]>

				</template>

			</defineLocation>

			<template location="HANDLECOMMANDL_METHOD"/>

			<defineLocation id="HANDLECOMMANDL_BODY" baseLocation="HANDLECOMMANDL_METHOD"

				owned="true"

				location="region(Generated Code)">

			</defineLocation>

			<template location="HANDLECOMMANDL_BODY" id="GenerateHandleCommandBody"><![CDATA[

TBool commandHandled = EFalse;

switch ( aCommand )

	{ // code to dispatch to the AppUi's menu and CBA commands is generated here

<%	var handlerContribs = Engine.generateChildContributions("HandleCommandSwitchDispatch");

		// resolve the contents for switch to this method

		var switchContribs = Engine.getContributionsForPhase(handlerContribs, "SwitchContents");

		Engine.assignLocationsForPhase(switchContribs, "SwitchContents", "HANDLECOMMANDL_BODY")

		contribs.addAll(switchContribs);

		handlerContribs.removeAll(switchContribs);

	%>	default:

		break;

	}

<%	// Handle any leftover handler contribs that occur after the switch here.

	var postSwitchContribs = Engine.getContributionsForPhase(handlerContribs, "PostSwitchContents");

	handlerContribs.removeAll(postSwitchContribs);

	Engine.assignLocationsForPhase(postSwitchContribs, "PostSwitchContents", "HANDLECOMMANDL_BODY")

	contribs.addAll(postSwitchContribs); 

	// add the rest, which presumably point to other locations

	contribs.addAll(handlerContribs); %>	

if ( !commandHandled ) 

	{<%

	var event = instance.events['handleCommand'];

	if (event) { 

%>		// dispatch to ${event.eventName} handler

	commandHandled = ${event.handlerName}( aCommand );

	if ( !commandHandled ) 

		{

		if ( aCommand == EAknSoftkeyExit || aCommand == EEikCmdExit )

			{

			Exit();

			}

		}<% } else { %>

	if ( aCommand == EAknSoftkeyExit || aCommand == EEikCmdExit )

		{

		Exit();

		}

<% }

%>	}

]]>			</template>

			<defineLocation id="HANDLERESOURCECHANGEL_METHOD" baseLocation="MAIN_FILE"

					owned="false"

					location="function(${handlerClassName}::HandleResourceChangeL(TInt))">

					<template><![CDATA[

/** 

 * Override of the HandleResourceChangeL virtual function

 */

void ${handlerClassName}::HandleResourceChangeL( TInt aType )

	{

	${instance.attributes["base-appui-class"]}::HandleResourceChangeL( aType );

	}

]]>				

					</template>

			</defineLocation>

			<template location="HANDLERESOURCECHANGEL_METHOD"/>

			<defineLocation id="HANDLERESOURCECHANGEL_BODY" baseLocation="HANDLERESOURCECHANGEL_METHOD"

					owned="true"

					location="region(Generated Code)">

			</defineLocation>

			<template location="HANDLERESOURCECHANGEL_BODY"/>

<!-- BEGIN EVENT handleKeyEvent -->

			<templateGroup id="GenerateHandleKeyEventHandler" ifEvents="handleKeyEvent">

				<template id="OverrideDecl" phase="OverriddenMethods"><![CDATA[

TKeyResponse HandleKeyEventL( 

		const TKeyEvent& aKeyEvent,

		TEventCode aType );

]]>				</template>

				<template id="HandlerDecl" phase="UserHandlers"><![CDATA[

TKeyResponse ${event.handlerName}( 

		const TKeyEvent& aKeyEvent, 

		TEventCode aType );

]]>				</template>

				<defineLocation id="KeyEventOverride_Method" baseLocation="MAIN_FILE"

					owned="false"

					location="function(${handlerClassName}::HandleKeyEventL(const TKeyEvent&,TEventCode))">

					<template><![CDATA[

/** 

 * Override of the HandleKeyEventL virtual function

 * @return EKeyWasConsumed if event was handled, EKeyWasNotConsumed if not

 */

TKeyResponse ${handlerClassName}::HandleKeyEventL( 

		const TKeyEvent& aKeyEvent, 

		TEventCode aType )

	{

		// The inherited HandleKeyEventL is private and cannot be called

	}

]]>				

					</template>

				</defineLocation>

				<template id="RealizeOverrideMethod" location="KeyEventOverride_Method"/>

				<defineLocation id="KeyEventOverride_Body" baseLocation="KeyEventOverride_Method"

					owned="true"

					location="region(Generated Code)">

				</defineLocation>

				<template id="DispatchToHandler" location="KeyEventOverride_Body"><![CDATA[

if ( ${event.handlerName}( aKeyEvent, aType ) == EKeyWasConsumed )

	{

	return EKeyWasConsumed;

	}

]]>				</template>

				<defineLocation id="KeyEventHandler" baseLocation="MAIN_FILE"

					owned="false"

					isEventHandler="true"

					location="function(${handlerClassName}::${event.handlerName}(const TKeyEvent&, TEventCode))">

					<template><![CDATA[

/** 

 * Handle the ${event.eventName} event.

 * @return EKeyWasConsumed if event was handled, EKeyWasNotConsumed if not

 */

TKeyResponse ${handlerClassName}::${event.handlerName}( 

		const TKeyEvent& /* aKeyEvent */, 

		TEventCode /* aType */ )

	{

	// TODO: implement ${event.eventName} event handler

	return EKeyWasNotConsumed;

	}

]]>				

					</template>

				</defineLocation>

				<template id="RealizeHandler" location="KeyEventHandler"/>

			</templateGroup>

<!-- END EVENT handleKeyEvent -->

<!-- BEGIN EVENT handleCommand -->

			<templateGroup id="GenerateHandleCommandEventHandler" ifEvents="handleCommand">

				<template id="1" phase="UserHandlers">

TBool ${event.handlerName}( TInt /* aCommand */);

				</template>

				<defineLocation id="CommandHandlerMethod" baseLocation="MAIN_FILE"

					owned="false"

					isEventHandler="true"

					location="function(${handlerClassName}::${event.handlerName}(TInt))">

					<template><![CDATA[

/** 

 * Handle the ${event.eventName} event.

 * @return ETrue if event was handled, EFalse if not

 */

TBool ${handlerClassName}::${event.handlerName}( TInt /* aCommand */)

	{

	// TODO: implement ${event.eventName} event handler

	return EFalse;

	}

]]>				

					</template>

				</defineLocation>

				<template id="2" location="CommandHandlerMethod"/>

			</templateGroup>

<!-- END EVENT handleCommand -->

<!-- BEGIN EVENT foregroundEvent -->

			<templateGroup id="GenerateForegroundEventHandler" ifEvents="foregroundEvent">

				<template id="OverrideDecl" phase="OverriddenMethods"><![CDATA[

void HandleForegroundEventL( TBool aForeground );

]]>				</template>

				<template id="HandlerDecl" phase="UserHandlers"><![CDATA[

void ${event.handlerName}( TBool aForeground );

]]>				</template>

				<defineLocation id="HandleForegroundOverride_Method" baseLocation="MAIN_FILE"

					owned="false"

					location="function(${handlerClassName}::HandleForegroundEventL(TBool))">

					<template><![CDATA[

/** 

 * Override of the HandleForegroundEventL virtual function

 */

void ${handlerClassName}::HandleForegroundEventL( TBool aForeground )

	{

	${instance.attributes["base-appui-class"]}::HandleForegroundEventL( aForeground );

	}

]]>				

					</template>

				</defineLocation>

				<template id="RealizeOverrideMethod" location="HandleForegroundOverride_Method"/>

				<defineLocation id="HandleForegroundOverride_Body" baseLocation="HandleForegroundOverride_Method"

					owned="true"

					location="region(Generated Code)">

				</defineLocation>

				<template id="DispatchToHandler" location="HandleForegroundOverride_Body"><![CDATA[

${event.handlerName}( aForeground );

]]>				</template>

				<defineLocation id="ForegroundEventHandler" baseLocation="MAIN_FILE"

					owned="false"

					isEventHandler="true"

					location="function(${handlerClassName}::${event.handlerName}(TBool))">

					<template><![CDATA[

/** 

 * Handle the ${event.eventName} event.

 */

void ${handlerClassName}::${event.handlerName}( TBool /* aForeground */ )

	{

	// TODO: implement ${event.eventName} event handler

	}

]]>				

					</template>

				</defineLocation>

				<template id="RealizeHandler" location="ForegroundEventHandler"/>

			</templateGroup>

<!-- END EVENT foregroundEvent -->

<!-- BEGIN EVENT switchOnEvent -->

			<templateGroup id="GenerateSwitchOnEventHandler" ifEvents="switchOnEvent">

				<template id="OverrideDecl" phase="OverriddenMethods"><![CDATA[

void HandleSwitchOnEventL( CCoeControl* aDestination );

]]>				</template>

				<template id="HandlerDecl" phase="UserHandlers"><![CDATA[

void ${event.handlerName}();

]]>				</template>

				<defineLocation id="HandleSwitchOnOverride_Method" baseLocation="MAIN_FILE"

					owned="false"

					location="function(${handlerClassName}::HandleSwitchOnEventL(CCoeControl*))">

					<template><![CDATA[

/** 

 * Override of the HandleSwitchOnEventL virtual function

 */

void ${handlerClassName}::HandleSwitchOnEventL( CCoeControl* /* aDestination */ )

	{

	// The inherited HandleSwitchOnEventL is private and cannot be called

	}

]]>				

					</template>

				</defineLocation>

				<template id="RealizeOverrideMethod" location="HandleSwitchOnOverride_Method"/>