/*
* Copyright (c) 2008 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:  Declares main application class.
 *
*/


#ifndef __MOUSE_H
#define __MOUSE_H

#include <e32std.h>
#include <w32std.h>

#include <e32msgqueue.h>
#include <e32cmn.h>
#include "pointmsgqueue.h"

#include "hidinterfaces.h"

class CField;
class CHidMouseDriver;

/*!
 HID mouse driver class
 */
class CHidMouseDriver : public CHidDriver //public CHidDriverPluginInterface
    {

private:
    /*! Initialisation states */
    enum TMouseDriverState
        {
        EUninitialised, /*!< Driver has not been initialised */
        EInitialised, /*!< Driver is initialised */
        EDisabled
        /*!< The driver will not respond to interrupt data */
        };

private:
    TMouseDriverState iDriverState;
    TInt iConnectionId;
    TInt iAppMenuId;

public:
    /*!
     Creates an instantiated CHidMouseDriver object.
     @param aHid The generic HID layer that requested the driver
     @param aFactory aFactory The factory that created the driver
     @result A pointer to the instantiated keyboard driver
     */
    static CHidMouseDriver* NewL(MDriverAccess* aHid);
    /*!
     Creates an instantiated CHidMouseDriver object and leaves it on the
     cleanup stack.
     @param aHid The generic HID layer that requested the driver
     @param aFactory aFactory The factory that created the driver
     @result A pointer to the instantiated keyboard driver
     */
    static CHidMouseDriver* NewLC(MDriverAccess* aHid);

    /*!
     Stops driver activity, deletes the key repeat and decode objects and closes
     the window server session before the driver is deleted
     */
    virtual ~CHidMouseDriver();

    /*!
     Called by the Generic HID layer to see if the driver can is able to use
     reports from a newly-connected device
     @result ETrue The driver can handle the reports
     @result EFalse The driver cannot handle the reports
     */
    virtual TInt CanHandleReportL(CReportRoot* aReportRoot);

    /*!
     Called by the Generic HID layer when a device has been removed, prior to the
     driver being removed.  This allows the driver to notify any applications of
     disconnection, if required
     @param aReason The reason for device disconnection
     */
    virtual void Disconnected(TInt aReason);

    /*!
     Called by the Generic HID layer when data has been received from the device
     handled by this driver.
     @param aChannel The channel on which the data was received (as defined by the
     transport layer
     @param aPayload A pointer to the data buffer
     */
    virtual TInt DataIn(CHidTransport::THidChannelType aChannel,
            const TDesC8& aPayload);

    /*!
     Called by the transport layers to inform the generic HID of the success of
     the last Set... command.
     @param aConnectionId ID of the device
     @param aCmdAck Status of the last Set... command
     */
    virtual void CommandResult(TInt aCmdAck);

    /*!
     Called after a driver is sucessfully created by the Generic HID, when a
     device is connected
     */
    virtual void InitialiseL(TInt aConnectionId);

    /*!
     Resets the internal state of the driver (any pressed keys are released) and
     enables the driver
     */
    virtual void StartL(TInt aConnectionId);
    /*!
     Cancels all pressed keys and disables the driver (so it will not
     process interrupt data)
     */
    virtual void Stop();

    virtual TInt SupportedFieldCount();

    /**
     * Set input handling registy 
     *
     * @since S60 v5.0     
     * @param aHandlingReg  a Input handling registry
     */
    virtual void SetInputHandlingReg(CHidInputDataHandlingReg* aHandlingReg);

    //redraw cursor
    void CursorRedraw();

private:
    // Constructor taking a pointer to the HID layer requesting the driver
    // instance
    CHidMouseDriver(MDriverAccess* aHid);

    void ConstructL();

private:
    // The types of keyboard input report fields that we handle:
    enum TKeyFieldType
        {
        EButtons = 0,
        EXY = 1,
        EWheel = 2,
        EMediaKeys = 3,
        EPowerKeys = 4,
        KNumInputFieldTypes
        };

private:
    // Called from within DataIn to handle interrupt and control channel data
    void InterruptData(const TDesC8& aPayload);

    // Handles the states of the XY (mouse up, down, left, right)
    void UpdateXY(TInt aFieldIndex, const TDesC8& aReport);

    // Handles the states of the Buttons (left & right button)
    void UpdateButtons(TInt aFieldIndex, const TDesC8& aReport);

    // Handles the states of the wheel
    void UpdateWheel(TInt aFieldIndex, const TDesC8& aReport);

    void MoveCursor(const TPoint& aPoint);
    TInt PostPointer(const TPoint& aPoint);
    TInt SendButtonEvent(TBool aButtonDown);

    void LaunchApplicationL(const TDesC& aName);
    
    TBool IsAlreadyRunning();

private:
    // The Generic HID layer
    MDriverAccess *iGenericHid;

    // Pointers to the fields in the report descriptor containing the
    // various types of key:
    const CField* iField[KNumInputFieldTypes];

    //Supported field types count
    TInt iSupportedFieldCount;

    CHidInputDataHandlingReg* iInputHandlingReg;
    RMsgQueue<TPointBuffer> iPointBufQueue;
    TPointBuffer iPointerBuffer;
    TBool iButtonDown;
    TBool iButton2Down;

    // A window server session, so keypresses can be sent to applications:
    RWsSession iWsSession;
    };

// ----------------------------------------------------------------------

#endif