diff -r 000000000000 -r a41df078684a kernel/eka/include/dispchannel.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/include/dispchannel.inl	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,588 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+//
+
+/**
+ @file dispchannel.inl
+ @publishedPartner
+ @released
+*/
+
+#ifndef __DISPCHANNEL_INL__
+#define __DISPCHANNEL_INL__
+
+#include <dispchannel.h>
+
+#ifndef __KERNEL_MODE__
+
+/** Creates a connection to the DisplayChannel Driver logical device driver.
+    This handle will need to be closed by calling Close()
+    when the connection to the Display Driver is no longer required.
+
+    @param aScreen  Identifies the screen this object will control
+    @return KErrNone if successful, otherwise one of the system-wide error codes.
+*/
+inline TInt RDisplayChannel::Open(TUint aScreen)
+	{
+	TVersion versionAlwaysSupported(KDisplayChMajorVersionNumberAlwaysSupported,
+                                    KDisplayChMinorVersionNumberAlwaysSupported,
+                                    KDisplayChBuildVersionNumberAlwaysSupported);
+	
+    TInt r = DoCreate(Name(), versionAlwaysSupported, aScreen, NULL, NULL);
+	return r;
+	}
+
+/** The connection is closed and the driver reverts back to legacy behaviour,
+    i.e. Non-GCE mode where the legacy buffer is used as the screen output
+*/
+inline void RDisplayChannel::Close(void)
+	{
+  	RBusLogicalChannel::Close();
+	}
+
+/** Get the static details of the display-owned composition buffer(s).
+    These are used with the address returned by GetCompositionBuffer()
+    to describe the current composition buffer.
+
+    The normal and flipped size information reflects the maximum direct access display resolution,
+    rather than the current resolution. The offset between lines remains constant,
+    regardless of current buffer format. See NextLineOffset() for specific buffer
+    format details.
+
+    The available rotations indicates all the possible rotations, across all
+    resolutions, even if not all are supported in all cases.
+
+    @see SetResolution
+    @see SetBufferFormat
+    @see NextLineOffset
+
+    @param aInfo The static details of the composition buffer(s).
+    @return KErrNone if successful, otherwise one of the system-wide error codes.
+*/
+inline TInt	RDisplayChannel::GetDisplayInfo(TDes8& aInfo)
+	{
+	return (DoControl(ECtrlGetDisplayInfo, &aInfo));
+    }
+
+/** Return the access details for a composition buffer, opening a new handle to the chunk containing
+    the composition buffer.  Note that because all returned information is static, this function will
+    normally only be called called once for each composition buffer when the RDisplayChannel is opened.
+
+    @param aBufferIndex  The index of a composition buffer.
+    @param aChunk A new open handle to chunk containing the composition buffer indexed by aBufferIndex.
+    @param aChunkOffset The offset from the base address of aChunk to the composition buffer indexed by aBufferIndex.
+    @return KErrNone if this command completed successfully, otherwise this is another of the system-wide error codes.
+*/
+inline TInt RDisplayChannel::GetCompositionBufferInfo(TUint aBufferIndex, RChunk& aChunk, TInt& aOffset)
+	{
+	TInt arg[2] = {0,0};
+	(DoControl(ECtrlGetCompositionBufferInfo, &aBufferIndex, &arg));
+    aChunk.SetHandle(arg[0]);
+    aOffset = arg[1];
+	return KErrNone;
+	}
+
+/** Request the driver to identify a driver-owned composition buffer for the user to render into.
+    This may not be completed until the next display refresh if the system is implementing multi-buffering
+    and there are no composition buffers available immediately.
+
+    @param  aBufferIndex On completion of aStatus, contains the buffer index of driver-owned buffer suitable
+    for client rendering.  The buffer access details can be retrieved by calling GetCompositionBufferInfo().
+    The remaining buffer attributes are described by GetDisplayInfo()
+    @param aStatus On completion, contains the status of the request. This is KErrNone if 
+    the system is multi-buffered and an available buffer was returned.  
+    This is KErrNone is the system is single-buffered and the primary buffer was returned.  
+    Otherwise this is another of the system-wide error codes.
+*/
+inline void	RDisplayChannel::GetCompositionBuffer(TUint& aIndex, TRequestStatus& aStatus)
+	{
+	DoRequest(EReqGetCompositionBuffer, aStatus, (TAny*)&aIndex);
+	}
+
+/** Cancel the outstanding request to GetCompositionBuffer()
+*/
+inline void	RDisplayChannel::CancelGetCompositionBuffer(void)
+	{
+	DoCancel(1<<ECtrlCancelGetCompositionBuffer);
+	}
+
+/** Tells the driver to queue a request to show the composition buffer on screen at the next display refresh.
+
+    @param aRegion The region changed by the client.  The driver may choose to optimise posting using this
+    information or it may ignore it.  Up to KMaxRectangles rectangles can be specified.  If null, the whole buffer is used.
+    @param aPostCount This is an identifier returned by the driver for this Post request on exiting the method
+*/
+inline TInt RDisplayChannel::PostCompositionBuffer(const TRegionFix<TDisplayInfo::KMaxRectangles>* aRegion, TPostCount& aCount)
+	{
+	return (DoControl(ECtrlPostCompositionBuffer, (TAny*)aRegion, &aCount));
+	}
+
+/** Request the driver to show the legacy buffer on screen at the next display refresh.
+    @param aPostCount This is an identifier returned by the driver for this Post request on exiting the method.
+    @return KErrNone if the request was queued successfully, otherwise this is another of the system-wide error codes.
+*/
+inline TInt	RDisplayChannel::PostLegacyBuffer(const TRegionFix<TDisplayInfo::KMaxRectangles>* aRegion, TPostCount& aCount)
+	{
+	return (DoControl(ECtrlPostLegacyBuffer, (TAny*)aRegion, &aCount));
+	}
+
+/** Register a user-provided buffer for use by the driver.  This enables the user to subsequently post the buffer. 
+    The number of registered buffers will need to have a limit and this is set to KMaxUserBuffers.
+
+    @param aBufferId Identifier to be used in the call to PostUserBuffer().
+    @param aChunk Chunk containing memory to be used by the driver.
+    @param aOffset Byte offset of the buffer from the chunk base.
+    @return KErrNone if the buffer has successfully registered.  
+    KErrTooBig if the number of registered buffers is at its limit when this call was made.  
+    Otherwise this is another of the system-wide error codes.
+*/
+inline TInt RDisplayChannel::RegisterUserBuffer(TBufferId& aBufferId, const RChunk& aChunk, TInt aOffset)
+	{
+	TInt arg[2] = {aChunk.Handle(), aOffset};
+	return (DoControl(ECtrlRegisterUserBuffer, arg, &aBufferId));
+	}
+
+/** Request the driver to show a buffer on screen at the next display refresh and notify the user when the buffer 
+    is no longer being displayed or has been dropped. Note that if two successive calls are made to PostUserBuffer() 
+    in between vertical sync pulses, the latest PostUserBuffer() call will supersede the previous call and will complete 
+    any outstanding request status object for that call with KErrCancel
+
+    @param aBufferId Identifier representing a buffer.  Generated by a previous call to RegisterUserBuffer().
+    @param aStatus On completion the submitted buffer is no longer in use by the display hardware, unless the same 
+    buffer is posted a second time before it has completed. aStatus contains the status of the request. This is KErrNone 
+    if the request was executed successfully.  This is KErrCancel if this posting request was superseded by a more recent request.  
+    This is KErrArgument if aBufferId is not a registered buffer. Otherwise this is another of the system-wide error codes.
+    @param aRegion The region changed by the client.  The driver may choose to optimise posting using this information or it may ignore it.  
+    Up to KMaxRectangles rectangles can be specified.  If null, the whole buffer is used.
+    @param aPostCount This is an identifier returned by the driver for this Post request on exiting the method.
+*/
+inline void RDisplayChannel::PostUserBuffer(TBufferId aBufferId, TRequestStatus& aStatus, const TRegionFix<TDisplayInfo::KMaxRectangles>* aRegion, TPostCount& aCount)
+	{
+	TInt arg[2] = {aBufferId, reinterpret_cast<const TInt>(aRegion)};
+	DoRequest(EReqPostUserBuffer, aStatus, arg, &aCount);
+	}
+
+/** Cancel the outstanding request to PostUserBuffer
+*/
+inline void RDisplayChannel::CancelPostUserBuffer(void)
+	{
+	DoCancel(1<<ECtrlCancelPostUserBuffer);
+	}
+
+/** Deregister a previously registered buffer.
+
+    @param aBufferId Identifier for a previously registered buffer, generated by a call to RegisterUserBuffer().
+    @return KErrNone if successful, KErrArgument if the token is not recognised, KErrInUse if the buffer is still in use,
+*/
+inline TInt RDisplayChannel::DeregisterUserBuffer(TBufferId aBufferId)
+	{
+	return (DoControl(ECtrlDeregisterUserBuffer, (TAny*)&aBufferId));
+	}
+
+/** This function allows the caller to be notified when a specified post either gets displayed or dropped.
+    Completes when a specified post request either gets displayed or dropped.  
+    Used to determine timing information for when a particular frame was displayed.
+
+    @param aPostCount An identifier representing a particular post request obtained from PostUserBuffer().
+    @param aStatus On completion, contains the status of the request. This is KErrNone if the post request was 
+    valid and was either displayed or dropped.  If aPostCount is less than the current count then this will complete 
+    immediately with KErrNone. Otherwise this is another of the system-wide error codes.
+*/
+inline void RDisplayChannel::WaitForPost(TPostCount aPostCount, TRequestStatus& aStatus)
+	{
+    DoRequest(EReqWaitForPost, aStatus, &aPostCount);
+	}
+
+/** Cancel the outstanding request to WaitForPost().
+*/
+inline void RDisplayChannel::CancelWaitForPost(void)
+	{
+	DoCancel(1<<ECtrlCancelWaitForPost);
+	}
+
+/** Ensures that the next post request will be displayed using the requested rotation.
+
+    @param aRotation A specific rotation value.
+    @param aDisplayConfigChanged Returns ETrue if the composition buffer is now using an alternative 
+    (either Normal or Flipped) orientation following this call.
+    @return KErrNone if rotation can be achieved.  KErrNotSupported if the requested rotation is not supported. 
+    Otherwise this is another of the system-wide error codes.
+*/
+inline TInt RDisplayChannel::SetRotation(TDisplayRotation aRotation, TBool& aDisplayConfigChanged)
+	{
+	aDisplayConfigChanged = EFalse;
+	return (DoControl(ECtrlSetRotation, &aRotation, &aDisplayConfigChanged));
+	}
+
+/** Return the current rotation setting of the display.
+*/
+inline RDisplayChannel::TDisplayRotation RDisplayChannel::CurrentRotation(void)
+	{
+    TDisplayRotation rotation = ERotationNormal;
+    DoControl(ECtrlCurrentRotation, &rotation);
+    return rotation;
+	}
+
+/** Asynchronous request for notification of when a display change occurs.
+    The request is completed when the connectedness of the display changes, or when
+    the set of available resolutions or pixel formats changes.
+    
+    If a failure occurs, it is passed back in the aStatus.
+
+    @panic DISPCHAN KNotificationAlreadySet if a notification request is pending.
+    @param aStatus    Completed on display change, or cancellation.
+*/
+inline void RDisplayChannel::NotifyOnDisplayChange(TRequestStatus& aStatus)
+	{
+	DoRequest(EReqWaitForDisplayConnect, aStatus);
+	}
+
+/** Cancels a pending request to notify on display change.
+
+    If there is a pending notification request, the status value will be set to
+    KErrCancelled and it will be completed. If there is no pending request for
+    notification, the call will simply return.
+*/
+inline void RDisplayChannel::NotifyOnDisplayChangeCancel()
+	{
+	DoCancel(1<<ECtrlCancelWaitForDisplayConnect);
+	}
+
+/** Returns the number of display resolutions currently available.
+
+    This is the maximum number of resolutions that can currently be retrieved using
+    GetResolutions() and set using a combination of SetResolution() and
+    SetRotation().
+    When no display is connected, there shall be a single entry.
+    
+    @return The number of TResolution elements that can be retrieved using
+    GetResolutions().
+*/
+inline TInt RDisplayChannel::NumberOfResolutions()  
+	{
+	return (DoControl(ECtrlNumberOfResolutions));
+	}
+
+/** Retrieves the resolutions that are currently available.
+
+    If the given buffer is large enough to hold them all, the set of available
+    resolutions shall be written to it as a contiguous sequence of TResolution
+    elements. aCount shall be set to the number of TResolution elements written and
+    the length of the buffer shall be set to the total number of bytes written.
+
+    If a display can be disabled or become disconnected, the list shall include the
+    size (0,0). If the display is connected but disabled, the list shall also
+    include the other supported resolutions. If a display cannot be disconnected or
+    disabled, the list shall not include (0,0).
+
+    @return KErrNone on success, KErrOverflow if the buffer is not large enough, or
+    KErrNotSupported if not supported by driver..
+    @param aResolutions    Buffer to receive resolutions, as a contiguous sequence
+    of TResolution elements.
+    @param aCount    The number of TResolution elements written to the buffer.
+*/
+inline TInt RDisplayChannel::GetResolutions(TDes8& aResolutions, TInt& aCount)  
+	{
+	return (DoControl(ECtrlGetResolutions,&aResolutions,&aCount));
+	}
+
+/** Sets the display's new pixel resolution.
+
+    The resolution shall be in terms of no rotation (ERotationNormal), but the
+    actual display output will depend on the current Rotation() value.
+
+    A successful call to this function may change any of the other attributes of
+    the display channel. The change to the attributes happens immediately, but the
+    change to the display output will only take place on the next buffer posting.
+
+    It is recommended that the implementation tries to minimize changes to other
+    attributes, if possible. For example, if the current rotation is set to
+    ERotation90CW and the new resolution supports that rotation, it should remain
+    as the current rotation. On the other hand, if the new resolution does not
+    support that rotation, it must be changed to a supported one.
+
+    If (0,0) is in the resolution list, passing a zero width and/or zero height
+    resolution shall select it, and shall have the effect of disabling output.
+
+    If either dimension of the given resolution is negative, KErrArgument shall be
+    returned. If the parameter is valid, but not currently available,
+    KErrNotSupported shall be returned.
+
+    @see GetResolutions
+    @capability WriteDeviceData Used to prevent arbitrary changes to the display
+    resolution.
+    @param aRes    The new display resolution.
+    @return KErrNone on success. KErrNotSupported, KErrOutOfMemory or KErrArgument
+    on failure.
+*/
+inline TInt RDisplayChannel::SetResolution(const TSize& aRes)
+	{
+	return (DoControl(ECtrlSetResolution,const_cast<TSize*>(&aRes)));
+	}
+
+/** Returns the current resolution.
+
+    This is always in terms of the ERotationNormal rotation regardless of current
+    and supported rotations. When the display is disconnected or disabled, this
+    returns (0,0).
+
+    If the current rotation is ERotation90CW or ERotation270CW, the width and
+    height values must be swapped by the caller to get the apparent width and
+    height.
+
+    @param aSize    Receives the current resolution.
+    @return KErrNone on success, KErrNotSupported if not supported by driver.
+*/
+inline TInt RDisplayChannel::GetResolution(TSize& aSize)  
+	{
+	return (DoControl(ECtrlGetResolution,&aSize));
+	}
+
+inline TInt RDisplayChannel::GetTwips(TSize& aTwips)
+	{
+	return (DoControl(ECtrlGetTwips,&aTwips));
+	}
+
+/** Returns the number of different buffer pixel formats that can be retrieved
+    using GetPixelFormats().
+
+    @return The number of pixel formats supported.
+*/
+inline TInt RDisplayChannel::NumberOfPixelFormats()  
+	{
+	return (DoControl(ECtrlNumberOfPixelFormats));
+	}
+
+/** Retrieves the buffer pixel formats that are supported.
+
+    If aFormatsBuf is large enough to hold them all, the set of available pixel
+    formats shall be written to it as a contiguous sequence of TPixelFormat
+    elements. aCount shall be set to the number of TPixelFormat elements written
+    and the length of the buffer shall be set to the total number of bytes written.
+
+    Not all pixel formats may be valid in all circumstances.
+
+    @see SetBufferFormat
+
+    @param aFormatsBuf    Buffer to receive pixel formats, as a contiguous sequence
+    of TUid elements.
+    @param aCount    Receives the number of TUid elements written to the buffer.
+    @return KErrNone on success, KErrOverflow if the buffer is too small to hold
+    all the elements, or KErrNotSupported if not supported by driver.
+*/
+inline TInt RDisplayChannel::GetPixelFormats(TDes8& aFormatsBuf, TInt& aCount)  
+	{
+	return (DoControl(ECtrlGetPixelFormats,&aFormatsBuf,&aCount));
+	}
+
+/** Sets the buffer format to be used when the next buffer is posted.
+
+    The width and height used in the buffer format correspond to the current
+    rotation in effect. The size in the buffer format must be at least as big as
+    the buffer mapping size, or the function shall fail with KErrNotSupported.
+
+    @see SetBufferMapping
+    @see PostCompositionBuffer
+    @see PostLegacyBuffer
+    @see PostUserBuffer
+
+    @capability WriteDeviceData Used to prevent arbitrary changes to the buffer
+    format.
+    @param aBufferFormat    The buffer format to be used.
+    @return KErrNone on success, KErrArgument if the buffer format is not valid,
+    KErrNotSupported if the format is valid but not supported, or KErrOutOfMemory
+    on memory allocation failure.
+*/
+inline TInt RDisplayChannel::SetBufferFormat(const TBufferFormat& aBufferFormat)
+	{
+	return (DoControl(ECtrlSetBufferFormat,const_cast<TBufferFormat*>(&aBufferFormat)));
+
+	}
+
+/** Retrieves the buffer format that will be used on the next buffer posting.
+
+    Initially, this will match the information returned by GetDisplayInfo() for the
+    current rotation.
+    When a new resolution, rotation or mapping is chosen, the buffer format may
+    change.
+
+    @param aBufferFormat    Receives the buffer format.
+    @return KErrNone on success, KErrNotSupported if not supported by driver.
+*/
+inline TInt RDisplayChannel::GetBufferFormat(TBufferFormat& aBufferFormat)  
+	{
+	return (DoControl(ECtrlGetBufferFormat,&aBufferFormat));
+	}
+
+/** Returns the offset in bytes from the start of a plane to the next one, for the
+    given buffer format.
+
+    This allows for additional bytes at the end of a plane before the start of the
+    next one, to allow for alignment, for example.
+
+    For packed pixel formats and interleaved planes in semi-planar formats, the
+    return value is zero.
+    
+    The current display channel resolution and the rotation is used in computing the
+    next plane offset.
+
+    @param aBufferFormat    A buffer width, in pixels.
+    @param aPlane    The plane number, starting at zero, for planar formats.
+    @return The next plane offset, in bytes, or zero if the parameters are invalid,
+    not recognised or not supported.
+*/
+inline TInt RDisplayChannel::NextPlaneOffset(const TBufferFormat& aBufferFormat, TInt aPlane) 
+	{
+	return (DoControl(ECtrlNextPlaneOffset,const_cast<TBufferFormat*>(&aBufferFormat),&aPlane));
+	}
+
+/** Returns the offset in bytes between pixels in adjacent lines, for the given
+    plane if relevant.
+
+    The value returned may allow for additional bytes at the end of each line, for
+    the purposes of alignment, for example. This is also known as the "stride" of
+    the line.
+
+    For packed pixel formats, aPlane is ignored. The offset returned shall be at
+    least the width in pixels multiplied by the bytes per pixel.
+
+    The current display channel resolution and the rotation is used in computing the
+    next line offset.
+    
+    For planar and semi-planar formats, aPlane dictates which offset is returned.
+    It must be at least the width in pixels multiplied by the (possibly fractional)
+    number of bytes per pixel for the plane.
+
+    @param aBufferFormat    The buffer format.
+    @param aPlane    The plane number, starting at zero.
+    @return The stride for a given combination of width in pixels and pixel format,
+    or zero if the parameters are invalid, not recognised or not supported.
+*/
+inline TInt RDisplayChannel::NextLineOffset(const TBufferFormat& aBufferFormat, TInt aPlane) 
+	{
+	return (DoControl(ECtrlNextLineOffset,const_cast<TBufferFormat*>(&aBufferFormat),&aPlane));
+	}
+
+/** Returns the offset in bytes from the start of a plane to the next one, for the
+    given parameters.
+
+    This allows for additional bytes at the end of a plane before the start of the
+    next one, to allow for alignment, for example.
+
+    For packed pixel formats and interleaved planes in semi-planar formats, the
+    return value is zero.
+
+    For planar and semi-planar formats, aPlane dictates which offset is returned.
+    It must be at least the width in pixels multiplied by the (possibly fractional)
+    number of bytes per pixel for the plane.
+
+    @param aBufferFormat    The buffer format.
+    @param aResolution	The resolution to be taken in consideration
+    @param aRotation    The rotation to be taken in consideration
+    @param aPlane    The plane number, starting at zero.
+    @return The stride for a given combination of width in pixels and pixel format,
+    or zero if the parameters are invalid, not recognised or not supported.
+*/
+inline TInt RDisplayChannel::NextPlaneOffset(const TBufferFormat& aBufferFormat, const TResolution& aResolution, TDisplayRotation aRotation, TInt aPlane)
+	{
+	TBufferFormatContext context(aResolution, aRotation, aPlane);
+	return (DoControl(ECtrlNextPlaneOffsetExtended, const_cast<TBufferFormat*>(&aBufferFormat), &context));
+	}
+
+/** Returns the offset in bytes between pixels in adjacent lines, for the given
+    plane if relevant.
+
+    The value returned may allow for additional bytes at the end of each line, for
+    the purposes of alignment, for example. This is also known as the "stride" of
+    the line.
+
+    For packed pixel formats, aPlane is ignored. The offset returned shall be at
+    least the width in pixels multiplied by the bytes per pixel.
+
+    For planar and semi-planar formats, aPlane dictates which offset is returned.
+    It must be at least the width in pixels multiplied by the (possibly fractional)
+    number of bytes per pixel for the plane.
+
+    @param aBufferFormat    The buffer format.
+    @param aResolution	The resolution to be taken in consideration
+    @param aRotation    The rotation to be taken in consideration
+    @param aPlane    The plane number, starting at zero.
+    @return The stride for a given combination of width in pixels and pixel format,
+    or zero if the parameters are invalid, not recognised or not supported.
+*/
+inline TInt RDisplayChannel::NextLineOffset(const TBufferFormat& aBufferFormat, const TResolution& aResolution, TDisplayRotation aRotation, TInt aPlane)
+	{
+	TBufferFormatContext context(aResolution, aRotation, aPlane);
+	return (DoControl(ECtrlNextLineOffsetExtended, const_cast<TBufferFormat*>(&aBufferFormat), &context));
+	}
+
+/** Returns the current version of the driver.
+*/
+inline TInt RDisplayChannel::Version(TVersion& aVersion) 
+	{
+	return (DoControl(ECtrlVersion, &aVersion));
+	}
+
+/** Constructs a resolution setting.
+
+    @param aSize    The resolution size in pixels, in ERotationNormal rotation.
+    @param aRotations    A bitwise combination of one or more TDisplayRotation
+    values.
+*/
+inline RDisplayChannel::TResolution::TResolution(TSize aPixelSize, TSize aTwipsSize, TUint32 aFlags):
+	iPixelSize(aPixelSize),iTwipsSize(aTwipsSize),iFlags(aFlags),reserved_0(0)
+	{	}
+
+/** Constructs a buffer format.
+
+    @param aSize    The size in pixels.
+    @param aPixelFormat    The pixel format.
+*/
+inline RDisplayChannel::TBufferFormat::TBufferFormat(TSize aSize, TPixelFormat aPixelFormat):
+	iSize(aSize),iPixelFormat(aPixelFormat),reserved_0(0)
+	{
+	}
+
+
+/** Constructs a buffer context.
+
+    @param aResolution    The display resolution.
+    @param aRotation    The display rotation.
+    @param aPlane
+*/
+inline RDisplayChannel::TBufferFormatContext::TBufferFormatContext(TResolution aResolution, TDisplayRotation aRotation, TInt aPlane):
+	iResolution(aResolution), iRotation(aRotation), iPlane(aPlane)
+	{
+	}
+
+
+#endif
+
+/**
+*/
+inline const TDesC& RDisplayChannel::Name()
+{
+ return (KDisplayDriverName);
+}
+
+/**
+*/
+inline TVersion RDisplayChannel::VersionRequired(void)
+{
+	return TVersion(KDisplayChMajorVersionNumber,
+				    KDisplayChMinorVersionNumber,
+			        KDisplayChBuildVersionNumber);
+}
+
+#endif // __DISPCHANNEL_INL__