/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#ifndef SWTEVENTQUEUE_H

#define SWTEVENTQUEUE_H

#include <e32base.h>

#include <jni.h>

#include "eswt.h"

class ASwtDisplayBase;

class CSwtEvent;

/**

 * CSwtEventQueue

 * A "first in / first out" queue for storing events until they are dispatched.

 * The queue is synchronised using a mutex to avoid concurrent accesses of

 * the main thread and the App UI's thread.

 * @lib eswt

 */

NONSHARABLE_CLASS(CSwtEventQueue)

        : public CBase

{

// Own methods

public:

    /**

     * Two phase constructor.

     * Must be executed from within the main thread.

     * @param aDisplay The display to be notified when an event is received.

     */

    static CSwtEventQueue* NewL(ASwtDisplayBase& aDisplay);

    /**

     * Destructor

     */

    virtual ~CSwtEventQueue();

    /**

     * Tests if the queue is empty.

     */

    TBool IsEmpty() const;

    /**

     * Appends an event at the end of queue and notifies of the reception

     * of an event. The queue takes ownership of the event.

     * Must be executed from within the App UI's thread.

     */

    void PushL(CSwtEvent* aEvent, const TBool& aInFront = EFalse);

    /**

     * Removes the oldest undispatched event from the queue and dispatches it.

     * If the queue contains no undispatched event, no event is dispatched

     * and EFalse is returned. Must be executed from within the main thread.

     * @return EFalse if a message was dispatched, ETrue otherwise.

     */

    TBool PopAndDispatch(JNIEnv& aJniEnv);

    /**

     * Removes all undispatched PaintEvent from the queue and dispatches it.

     * Must be executed from within the main thread. This method is used by

     * Update() method.

     * @param aSwtControl If equals NULL then all paint events of all control

     * are dispatch otherwise only the paint event of the Control correspondent

     * to Peer was dispatched.

     */

    void PopAndDispatchPaintEvents(JNIEnv& aJniEnv, MSwtControl* aSwtControl);

    /**

     * Prepares the queue for destruction. The queue will no longer notify

     * of new events it receives.

     */

    void PrepareForDestruction();

    /**

     * Test whether the queue is about to be destroyed. This is a way for

     * letting events check if the display was disposed and thus stop

     * executing.

     */

    TBool IsDestroying() const;

    /**

     * Destroys all undispatched events the queue still holds.

     * Must be executed from within the App UI's thread.

     */

    void Flush();

    /**

     * Informs the event queue that the specified Java object has been disposed.

     * Must be executed from within the main thread.

     */

    void PeerDisposed(TSwtPeer aPeer);

    /**

     * Turns on/off aggressive paint merging. If the aggressive paint merging

     * is turned on, all the paint events of a control are merged, disregarding

     * non paint events positioned in between them.

     */

    void SetOptimizedPaint(TBool aStatus);

private:

    /**

     * First phase constructor.

     * @param aDisplay The display to be notified when an event is received.

     */

    CSwtEventQueue(ASwtDisplayBase& aDisplay);

    /**

     * Second phase constructor.

     */

    void ConstructL();

    /**

     * PushL helper.

     */

    void DoPushL(CSwtEvent* aEvent, const TBool& aInFront);

    /**

     * Tests if the queue is empty, but does not use the mutex.

     */

    TBool IsEmptyNoMutex() const;

// Data types

private:

    typedef CArrayPtrFlat<CSwtEvent> CEventArray;

// Data

private:

    /**

     * The events, may be NULL. Both the array and the events are on the UI's heap

     * Own.

     */

    CEventArray* iEvents;

    /**

     * Related display reference.

     */

    ASwtDisplayBase& iDisplay;

    /**

     * The mutex.

     * Own.

     */

    mutable RMutex iMutex;

    /**

     * The number of events currently being dispatched

     */

    volatile TInt iDispatchingCount;

    /**

     * Flag indicating whether destruction is ongoing.

     */

    TBool iDestroying;

    /**

     * Flag indicating whether aggressive paint merging is allowed.

     * Set to ETrue when the application registers paint listeners.

     */

    TBool iOptimizedPaint;

};

#endif // SWTEVENTQUEUE_H