/*
* Copyright (c) 2007 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:  
*     Pure virtua class for message view to handle listbox.
*
*/



#ifndef MCEMESSAGELISTCONTAINERBASE_H
#define MCEMESSAGELISTCONTAINERBASE_H

//  INCLUDES
#include <coecntrl.h> // CCoeControl
#include <msvapi.h>
#include <aknmarkingmodeobserver.h>
//#include "MceListContainer.h"
//#include "MceMessageListContTimer.h"

#include "mcetemplate.h"
#include "MceUtils.h"
#include "MceListItem.h"
#include <centralrepository.h> //CRepository
#include <bldvariant.hrh>
#include <eikcmobs.h>
#include <e32property.h>

// FORWARD DECLARATIONS
class CMceMessageListView;
class MMtmUiDataRegistryObserver;

//CONSTS
//const TInt KMceSelectionReplacementSize = 5;
enum TMceContainerFlags
    {
    EMceOneRowFlagOptionsMenuOpen   = 0x01, // options menu open status
    EMceOneRowFlagFirstSubtitleOpen = 0x02
    };


// CLASS DECLARATION

/**
* Base class for all the message list containers. 
* This class is used by message list view.
* @since S60 5.0
*/
class  CMceMessageListContainerBase :
    public CCoeControl,
    public MEikCommandObserver,
    public MAknMarkingModeObserver
    {
    public:  // Constructors and destructor

        /**
        * Destructor.
        */
        virtual ~CMceMessageListContainerBase();
		
    public: // From MAknMarkingModeObserver 
            
        /**
         * This method is called when marking mode is activated or deactivated.
         * 
         * @param aActivated @c ETrue if marking mode was activate, @c EFalse
         *                   		  if marking mode was deactivated.
         */
        void MarkingModeStatusChanged( TBool aActivated );

        /**
         * This method is called just before marking mode is closed. Client can 
         * either accept or decline closing.
         * 
         * @return @c ETrue if marking mode should be closed, otherwise @c EFalse.
         */
        TBool ExitMarkingMode() const;           

    public:
    
        /**
        * TODO: Needed?
        * 1 = two row
        * 2 = hierachical list
        */
        virtual TInt MceListId() const = 0;
    
        /**
        * @return number of items in list (total list item count, including ALL the items with one row list)
        */
        virtual TInt Count() const = 0;
        
        /**
        * @return message count
        */
        virtual TInt MessageCount() const = 0;
        
        /**
        * @return folder count
        * TODO: some other count also needed? Subtitle row count?
        */
        virtual TInt FolderCount() const = 0;
        
        /**
        * Changes currently opened folder
        * @param aFolderId: id of the folder to be opened.
        * TODO: should this open inbox in case of imap?
        */
        virtual void SetFolderL( TMsvId aFolderId ) = 0;
        
        /**
        * Returns id of the currently opened folder
        * @return folder id
        */
        virtual TMsvId CurrentFolderId() const = 0;
        
        /**
        * Returns the currently opened folder entry.
        * @return TMsvEntry of the opened folder.
        */
        virtual const TMsvEntry& FolderEntry() const = 0;

        
        /**
        * Returns message id of the currently focused item
        * @return TMsvId of the entry
        * TODO: should this be TInt so that it could be used to subtitles?
        */
        virtual TMsvId  CurrentItemId() const = 0;

        /**
        * TMessageListItemType
        * different list item types, CurrentItemType
        */
        enum TMessageListItemType
            {
            /**
            * unknown item (list is empty?)
            */
            EMessageListItemUnknown = 0,
            
            /**
            * Item can be found from message store (CurrentItemId() returns TMsvId)
            */
            EMessageListItemMsvItem,
            
            /**
            * something else ( one row list; subtitle?)
            */
            EMessageListItemSubtitle,
            
            /**
            * Tree list root
            */
            EMessageListItemRoot
            };
            
        /**
        * @return Type of the currently focused item
        */
        virtual TMessageListItemType CurrentItemType() const = 0;
        
        /**
        * Changes focus to the entry of the given id.
        * @return ETrue if aEntryId found otherwise EFalse.
        */
        virtual TBool SetCurrentItemIdL( TMsvId aEntryId ) = 0;
        
        /**
        * Changes focus to the first entry.
        */
        virtual void ResetCurrentItemL() = 0;
        
        
        /**
        * Searches aMatchString from the list and returns first found entry id.
        * Returns KErrNotFound if not found.
        * TODO: container should move focus automatically?
        */
        virtual TMsvId FindEntry( const TDesC& aMatchString ) const = 0;
        
        /**
        * Finds first unread message from the opened folder. 
        * aEntry is set KErrNotFound if no unread messages in the folder,
        * otherwise id of the first unread message.
        * @return ETrue if exactly one unread message in current folder
        * EFalse otherwise.
        */
        virtual TBool FindFirstUnreadMessageL( TMsvId& aEntryId ) const = 0;
        
        /**
        * TODO: that is not needed if container would be msv session observer
        */
        virtual void ItemCountChangedL( TBool aItemsAdded, CArrayFix<TInt>*
                aAddedIndexes = 0 ) = 0;
        
        /**
        * Redraw the listbox.
        */
        virtual void RefreshListbox() = 0;
        
        /**
        * Returns array of currently selected (marked) messages.
        * (Focus is added, if no other markings)
        * Caller's responsibility to destroy array!
        * @return Array of selected items.
        */
        virtual CMsvEntrySelection* CurrentItemSelectionL() = 0;

        /**
        * Refreshes selection by calling MarkItemSelectionL and
        * then returns selection by calling CurrentItemSelectionL
        * Caller's responsibility to destroy array!
        * @return Array of selected items.
        */
        virtual CMsvEntrySelection* CurrentItemSelectionRefreshL() = 0;

        /**
        * Returns number of marked items including focus if no other selections.
        * @return Number of items marked, if no marked items then 1 is returned (focus).
        * 0 is returned only if list is empty.
        */
        virtual TInt CurrentItemSelectionCount() const = 0;
        
        /**
        * Returns number of selected/marked messages, focus is not included.
        * @return Number of items selected (0 or more)
        */
        virtual TInt SelectionCount() const = 0;
        
        /**
        * Returns ETrue if aItemId is marked.
        */
        virtual TBool IsItemSelected( TMsvId aItemId ) = 0;

        /**
        * Clears selection.
        */
        virtual void ClearSelection() = 0;

        /**
        * Reads selected item indexes from the listbox and then stores
        * selected items TMsvId's to iSelectedEntries array.
        * If no items marked then currently selected item is added to array
        *
        * This can be called when for example opening options menu. Options menu
        * can overlap whole list box and if then new message is received it is selected
        * on background. Now if user selected 'Delete' then message which was selected
        * before opening options menu is deleted, not just received message because
        * it is stored by this function.
        */
        virtual void MarkItemSelectionL() = 0;

        /**
        * Adds currently focused item to marked array.
        */
        virtual void AddCurrentItemToSelectionL() = 0;

        /**
        * Removes currently selected item (== 'cursor') from selected array
        */
        virtual void RemoveCurrentItemFromSelection() = 0;

        /**
        * TODO: update description for more generic. Now it is only for old list:
        * Updates selection indexes by reading selected message's TMsvIds from iSelectedEntries
        * and creates new CSelectionIndexArray.
        * @param aForceUpdate: set ETrue if index update is wanted to be done even when
        *   listbox's selection does not include any items.
        *   Usually this is set true only when calling from CMceBaseListView::HandleEntriesDeletedL
        */
        virtual void RefreshSelectionIndexesL( TBool aForceUpdate ) = 0 ;

        /**
        * Adds all the messages to listbox selection index array
        */
        virtual void AddAllToSelectionL() = 0;
        
        /**
        * Mark all read messages.
        */
        virtual void MarkAllReadMessagesL() = 0;
        
        /**
        * Return the count of marked items. if there is no marked item, returns 0;
        */
        virtual TInt MarkedItemsCount() = 0;

        /**
        * Checks if currently selected item is folder.
        * @return ETrue if item aItemId is folder.
        * NOTE: aItemId must be found from msg store. 
        *       if item not found, returns EFalse;
        */
        virtual TBool IsItemFolder( TMsvId aItemId ) const = 0;
        
        /**
        * Returns ETrue if aItemId is under remote service
        */
        virtual TBool IsItemRemote( TMsvId aItemId ) const = 0;

        /**
        * checks if aFolderId is currently opened
        * Return ETrue if currently opened folder is aFolderId
        * For example if needs to be checked if outbox is opened call:
        *   IsOpenedFolder( KMsvGlobalOutBoxIndexEntryId )
        */
        virtual TBool IsOpenedFolder( TMsvId aFolderId ) const = 0;

        /**
        * Sets sort order
        * @param aSortType: from MceCommands.hrh
        * @param aOrdering: sort ordering(ascending/descending)  
        */
        virtual void SetSortTypeL( TInt aSortType, TBool aOrdering ) = 0;
        
        /**
        *
        */
        virtual void SetMtmUiDataRegistry( MMtmUiDataRegistryObserver* aRegistryObserver ) = 0;

        /**
        * Sets empty text for the listbox.
        * @param aText: empty text
        */
        virtual void SetListEmptyTextL(const TDesC& aText) = 0;
        
        /**
        * TMessageListOperationType
        * different mailbox operation types to handle cursor 
        */
        enum TMessageListOperationType
            {
            /**
            *
            */
            EMessageListOperationGeneral = 0,
            
            /**
            *
            */
            EMessageListOperationConnect,
            
            /**
            *
            */
            EMessageListOperationFetchSelected,
            
            /**
            *
            */
            EMessageListOperationFetchNew,
            
            /**
            *
            */
            EMessageListOperationDelete,
            
            /**
            * Called when operation is completed
            * NOTE: this is not 100% to be called when operation is ready.
            *   For example imap4 create connection operation is not completed
            *   when connection is created, onle when connection is closed!
            */
            EMessageListOperationCompleted
            };

        
        /**
        * Called by application when operation is started.
        * List container can set anchor item or what ever it wants to keep 
        * focus in sensible place during the operation.
        * OPEN:
        * Problem is that operation completion is not informed so
        * listcontainer should handle that somehow...?
        */
        virtual void SetAnchorItemIdL( 
            TMessageListOperationType aOperationType ) = 0;
            
        /**
        * TODO: that is not needed if container would be msv session observer
        * TODO: remove ItemCountChangedL
        * @param aEvent: notified events: 
        *   EMsvEntriesDeleted, EMsvEntriesCreated, EMsvEntriesChanged
        * @param aSelection: CMsvEntrySelection of the entries changed/deleted/created.
        * @param aDrawNow: EFalse means CMceUi has ViewUpdateSuppressionFlag ON
        *   so listbox should not redraw itself, then only update anchor item etc.
        *   When operation is completed then container will get 
        *   SetAnchorItemIdL call with parameter EMessageListOperationCompleted.
        *   ETrue means that listbox can redraw itself if needed.
        * See also SetAnchorItemIdL
        */
        virtual void HandleMsvSessionEventL( 
            MMsvSessionObserver::TMsvSessionEvent aEvent,
            CMsvEntrySelection& aSelection,
            TBool aDraw ) = 0;
            
        /**
        * Returns ETrue if empty list or there are items selected.
        */
        virtual TBool DisplayOptionsMenuFromSelectionKey() const = 0;

        
        /**
        * Used to show different menu command offered by message list view
        * At the moment there are only Expand and Collapse options menu items 
        * but there can be more...
        */
        enum 
            {
            /**
            * Return TMessageListCommandNone if all the menu items dimmed,
            * otherwise corresponding flag value. 
            */
            TMessageListCommandNone = 0,
            /**
            * TMessageListCommandExpand: return this if expand command is visible.
            */
            TMessageListCommandExpand = 0x01,
            /**
            * TMessageListCommandCollapse1: return this if collapse, which is 
            *    immediately after expand command, is visible.
            */
            TMessageListCommandCollapse1 = 0x02,
            /**
            * TMessageListCommandCollapse2: return this if collapse, which is 
            *    after reply command, is visible.
            */
            TMessageListCommandCollapse2 = 0x04
            };
            
        /**
        * Return correct flag to set command visible in message 
        * list view's options menu. 
        * if expand valid command, then return TMessageListCommandExpand,
        * if collapse valid command, then return either TMessageListCommandCollapse1 
        *    or TMessageListCommandCollapse2 but NOT both.
        */
        virtual TUint OptionsCommandSupported() const = 0;
        
        /**
        *
        */
        virtual void HandleOptionsCommandL( TInt aCommand ) = 0;
        
        /**
        * Called when time or date format has been changed or 
        *   midnight is passed. 
        * @param aChangeFlag: flag defined in TChanges in e32const.h.
        *   Notifies only the following events:
        *   - EChangesLocale
        *   - EChangesMidnightCrossover
        *   - EChangesSystemTime
        */
        virtual void DateTimeFormatChangedL( TInt aChangeFlag ) = 0;

        /**
        * Returns container Msk
        */
        virtual TInt SetSpecialMskL() = 0;

        /**
        * Sets message list container flags
        * @param aFlag: Name of the flag
        * @param aState: State for the flag
        */
        virtual void SetContainerFlag( TMceContainerFlags aFlag, TBool aState ) = 0;

        /**
        *  Updates icon array in case MTM is released (one row list)
        */
        virtual void UpdateIconArrayL() = 0;
		
        /**
        *  Sets Marking mode Off
        */
       
        virtual void SetMarkingModeOff() = 0;
        
    protected:
    
        /**
        *
        */
        CMceMessageListContainerBase( CMceMessageListView& aOwningView );
        
    protected:

        CMceMessageListView&            iOwningView;        

    };
    

#endif

// End of file
