/*
* Copyright (c) 2008-2009 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:    Marking command handler
*
*/




#ifndef C_GLXCOMMANDHANDLERMARKING_H
#define C_GLXCOMMANDHANDLERMARKING_H

#include <e32base.h>
#include <glxmedialistcommandhandler.h>
#include <mglxsoftkeyhandler.h>

class MGlxMediaListProvider;

class MGlxVisualList;
class CGlxMarkedIconManager;
class MGlxSoftkeyHandler;
class CGlxUiUtility;
class CGlxVisualListManager;
class CGlxScreenFurniture;


/**
 * CGlxCommandHandlerMarking
 *
 * Marking  command handler implementation
 *
 * @lib glxcommandhandlermarking
 * @author M Byrne
 * @internal reviewed 11/06/2007 by Alex Birkett
 * @internal reviewed 19/09/2007 by Aki Vanhatalo
 */
NONSHARABLE_CLASS (CGlxCommandHandlerMarking) : public CGlxMediaListCommandHandler,
        public MGlxMediaListObserver
    {
public:
    /**
     * Static construction function
     * @param aMediaListProvider pointer to media list owner
     * @param aKeyHandler pointer to MGlxSoftkeyHandler interface
     * @param aUpdateMiddleSoftkey Should this command handler update
     *          the middle softkey when not in multiple marking mode.
     * @return pointer to CGlxCommandHandlerMarking object
     */
    IMPORT_C static CGlxCommandHandlerMarking* NewL(
                                MGlxMediaListProvider* aMediaListProvider, 
                                TBool aHasToolbarItem/*,
                                TBool aUpdateMiddleSoftkey = EFalse */);
                                
    /** Destructor */
    IMPORT_C ~CGlxCommandHandlerMarking();

public: // From CGlxCommandHandler
    void DoActivateL(TInt aViewId);
    void Deactivate();
    TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType);
    void HandleItemAddedL(TInt aStartIndex, TInt aEndIndex, 
                                            MGlxMediaList* aList);
    
    void HandleMediaL(TInt aListIndex, MGlxMediaList* aList);
public: // From MGlxMediaListObserver
    void HandleItemRemovedL(TInt aStartIndex, TInt aEndIndex, 
                                        MGlxMediaList* aList);
    void HandleItemModifiedL(const RArray<TInt>& aItemIndexes, 
                                        MGlxMediaList* aList);
    void HandleAttributesAvailableL(TInt aItemIndex,     
        const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* aList);
    void HandleFocusChangedL(NGlxListDefs::TFocusChangeType aType, 
                        TInt aNewIndex, TInt aOldIndex, MGlxMediaList* aList);
    void HandleItemSelectedL(TInt aIndex, TBool aSelected, MGlxMediaList* aList);
    void HandleMessageL(const CMPXMessage& aMessage, MGlxMediaList* aList);
    
protected: // From CGlxCommandHandler
    void PopulateToolbarL();
    
protected: // From CGlxMediaListCommandHandler
    TBool DoExecuteL(TInt aCommand, MGlxMediaList& aList);
    void DoDynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane);
    TBool DoIsDisabled(TInt aCommandId, MGlxMediaList& aList) const;
    
private:
    /** Current marking mode marking or unmarking */
    enum TGlxMarkingMode
        {
        EMarking,
        EUnmarking
        };

    /** status of left softkey (in mupltiple marking mode) */
    enum TGlxLeftSoftKeyStatus
        {
        EGlxLSKUndefined,
        EGlxLSKBlank, // static item
        EGlxLSKMark,
        EGlxLSKUnmark
        };
        
    /**
      * 2nd phase construction
      */
    void ConstructL();

    /**
     * Constructor
     * @param aMediaListProvider pointer to media list owner
     * @param aKeyHandler pointer to MGlxSoftkeyHandler interface
     * @param aUpdateMiddleSoftkey Should this command handler update
     *          the middle softkey when not in multiple marking mode.
     */
    CGlxCommandHandlerMarking( MGlxMediaListProvider* aMediaListProvider,
    		TBool aHasToolbarItem/* , TBool aUpdateMiddleSoftkey */);

    /**
     * Select/unselect all items 
     * @param aSelect select if ETrue unselect otherwise
     */
    void SelectAllL( TBool aSelect );

    /**
     * Enter multiple marking mode
     */
    void EnterMultipleMarkingModeL();

    /**
     * Exit multiple marking mode
     */
    void ExitMultipleMarkingModeL();

    /**
     * Update mark status of selected item
     * and update marked item count
     * @param aList media list
     * @param aIndex index of item in media list
     */
    void SetSelectedL(MGlxMediaList* aList, TInt aIndex);

private:
    /** Resource offset */
    TInt iResourceOffset;

    /**  Flag if basic marking in operation */
    TBool iBasicMarking;

    /** multiple marking mode enabled */
    TBool iMultipleMarking;

    /** Current marking mode (marking or unmarking) */
    TGlxMarkingMode iMarkingMode;

    /** visual list passed through to marking icon manager */
    MGlxVisualList* iVisualList;

    /** ID of view activating command handler */	
    TInt    iViewId;

    // add current lsk status
    TGlxLeftSoftKeyStatus iLeftSoftKeyStatus;

    /** Whether to update the MSK when not in multiple marking mode */
    TBool iUpdateMiddleSoftkey;

    /** Whether context menu is currently enabled */
    TBool iOkOptionsMenuEnabled;

    /** Current middle softkey text resource */
    TInt iMskTextResourceId;

    /**  Instance of Ui utility class  */
    CGlxUiUtility* iUiUtility;

    /**  Instance of Screenfurniture  */
    CGlxScreenFurniture* iScreenFurniture ;
    
    /** Flag to indicate whether full-screen is active or not */
    TBool iInFullScreen;
    
    HBufC* iRskTextCancel;
    HBufC* iRskTextBack;
    HBufC* iMskTextMark;
    HBufC* iMskTextUnMark;
    HBufC* iMskTextOpen;
    
    };

#endif // C_GLXCOMMANDHANDLERMARKING_H