/*
* 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: Implementation for CVIMPSTUiDoubleListBoxTabViewControl.
*
*/
// INCLUDE FILES
#include "cvimpstuidoublelistboxtabviewcontrol.h"
#include "cvimpstuidoublelistboxarray.h"
#include "tvimpstenums.h"
#include "mvimpstcmdhandler.h"
#include "cvimpstuibranddata.h"
#include "imcvuiliterals.h"
#include "cvimpstuilistboxmodel.h"
#include "vimpstutilsdialog.h"
#include "vimpstui.hrh"
#include "cvimpstuitabbedview.h"
#include "mvimpstengine.h"
#include "cvimpststoragemanagerfactory.h"
#include "mvimpststorageserviceview.h"
#include "cvimpstsettingsstore.h" // settings store in cenrep used for own avatar data
#include "cvimpstengineimagehandler.h"
// system include
#include <aknenv.h>
#include <aknlists.h>
#include <AknIconArray.h>
#include <eikclbd.h>
#include <aknsfld.h>
#include <AknUtils.h>
#include <AknLayout.lag>
#include <StringLoader.h>
// Pbk2
#include <MPbk2KeyEventHandler.h>
#include <vimpstuires.rsg>
#include <aknlayoutscalable_avkon.cdl.h>
#include "uiservicetabtracer.h"
// imlauncher
#include <imcvlauncher.h>
const TInt KTextLimit( 40 ); // Text-limit for find-field
const TInt KMinContact(1); // minmimum number of contacts to show findpane
// ================= MEMBER FUNCTIONS =======================
inline CVIMPSTUiDoubleStyleListBox& CVIMPSTUiDoubleListBoxTabViewControl::ListBox() const
{
return(*iListBox);
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::CVIMPSTUiDoubleListBoxTabViewControl
// --------------------------------------------------------------------------
//
CVIMPSTUiDoubleListBoxTabViewControl::CVIMPSTUiDoubleListBoxTabViewControl(CVIMPSTUiTabbedView& aTabbedView, MPbk2KeyEventHandler* aKeyEventHandler,
MVIMPSTCmdHandler& aCommandHandler,
TUint32 aServiceId,
CVIMPSTUiBrandData& aBrandHandler,
MVIMPSTEngine& aEngine )
:iTabbedView(aTabbedView),
iKeyEventHandler(aKeyEventHandler),
iCommandHandler(aCommandHandler),
iArrayProcess(iCommandHandler.GetProcessInterface()),
iServiceId(aServiceId),
iBrandHandler(aBrandHandler),
iEngine(aEngine)
{
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::ConstructL
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::ConstructL()
{
TRACER_AUTO;
CreateWindowL();
// register to get the call back for any array data change
iArrayProcess.AddObserver(this);
// this to make sure that if user id changed storage should be refresh with new user id
// Initialize the listbox
// Create and construct listbox
iListBox = new ( ELeave ) CVIMPSTUiDoubleStyleListBox;
iListBox->ConstructL(this , EAknListBoxSelectionList);
iListBox->SetContactListModelL(iArrayProcess);
iListBox->SetListBoxObserver( this );
iListBox->SetContainerWindowL(*this);
iListBox->CreateScrollBarFrameL(ETrue);
iListBox->ScrollBarFrame()->SetScrollBarVisibilityL
(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
// set marquee on
iListBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue );
// If engine is uninstalled, do not construct the list view.
// Display empty message
if (iEngine.IsUnInstalled())
{
SetListEmptyTextL( R_QTN_SERVTAB_SWUPDATE_RESTART );
return;
}
else
{
// Construction of the listbox view. Engine is not uninstalled.
CVIMPSTUiDoubleListboxArray* friendsArray =
CVIMPSTUiDoubleListboxArray::NewL(iArrayProcess,
iListBox->ItemDrawer()->ColumnData(), *iListBox,
*this);
// now set the array
iListBox->Model()->SetItemTextArray(friendsArray);
iListBox->Model()->SetOwnershipType(ELbmOwnsItemArray);
// if there is any contact other than owndata , show findpane
if (iListBox->Model()->NumberOfItems() > KMinContact)
{
// Create find-pane
ActivateFindPaneL();
}
LoadBitmapsL();
SetCbaLockL(EFalse);
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::NewL
// --------------------------------------------------------------------------
//
CVIMPSTUiDoubleListBoxTabViewControl* CVIMPSTUiDoubleListBoxTabViewControl::NewL
(CVIMPSTUiTabbedView& aTabbedView,MPbk2KeyEventHandler* aKeyEventHandler,
MVIMPSTCmdHandler& aCommandHandler, TUint32 aServiceId,
CVIMPSTUiBrandData& aBrandHandler,
MVIMPSTEngine& aEngine)
{
TRACER_AUTO;
CVIMPSTUiDoubleListBoxTabViewControl* self = NewLC(aTabbedView,aKeyEventHandler,
aCommandHandler, aServiceId, aBrandHandler,aEngine);
CleanupStack::Pop(self);
return self;
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::NewLC
// --------------------------------------------------------------------------
//
CVIMPSTUiDoubleListBoxTabViewControl* CVIMPSTUiDoubleListBoxTabViewControl::NewLC
(CVIMPSTUiTabbedView& aTabbedView,MPbk2KeyEventHandler* aKeyEventHandler,
MVIMPSTCmdHandler& aCommandHandler, TUint32 aServiceId,
CVIMPSTUiBrandData& aBrandHandler,
MVIMPSTEngine& aEngine)
{
TRACER_AUTO;
CVIMPSTUiDoubleListBoxTabViewControl* self =
new (ELeave) CVIMPSTUiDoubleListBoxTabViewControl(aTabbedView,aKeyEventHandler,
aCommandHandler, aServiceId, aBrandHandler,aEngine);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::~CVIMPSTUiDoubleListBoxTabViewControl
// --------------------------------------------------------------------------
//
CVIMPSTUiDoubleListBoxTabViewControl::~CVIMPSTUiDoubleListBoxTabViewControl()
{
delete iListBox;
iArrayProcess.RemoveObserver();
if( iFindbox )
{
delete iFindbox;
iFindbox = NULL;
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleAvatarChangeL
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::HandleAvatarChangeL( const TDesC& aUserId )
{
TRACER_AUTO;
TRACE( "aUserId = %S ", &aUserId );
CFormattedCellListBoxData* listBoxData = iListBox->ItemDrawer()->ColumnData();
TPtrC loginUserId = iArrayProcess.LoginUserIdFromStoreL();
TInt Avindex = 0;
CGulIcon* newIcon = NULL;
TRACE( "loginUserId = %S ", &loginUserId );
if( KErrNone == loginUserId.Compare( aUserId ) )
{
TRACE( "inside if ownuserid" );
TPtrC8 avatardata = iArrayProcess.OwnAvatarContentL();
TRACE( "after iArrayProcess.OwnAvatarContentL()" );
Avindex = iArrayProcess.OwnAvatarIndexL();
if( avatardata.Length() )
{
TRACE( "avatardata.Length()" );
newIcon = AvatarToIconL( avatardata );
}
if( newIcon ) // there is a new avatar icon
{
TRACE("newIcon" );
CArrayPtr<CGulIcon>* currentIconArray = listBoxData->IconArray();
if( Avindex ) // if there is old icon already
{
TRACE( "Avindex " );
// delete the old icon compress the array and insert at the same position
currentIconArray->Delete( Avindex );
currentIconArray->Compress();
currentIconArray->InsertL( Avindex , newIcon);
}
else
{
TRACE( "else of Avindex " );
// if there is no old icon append at the last
currentIconArray->AppendL( newIcon);
// set the index to cenrep
TRACE( " currentIconArray->Count()-1 = %d ",currentIconArray->Count()-1 );
iArrayProcess.SetOwnAvatarIndexL( currentIconArray->Count()-1 );
}
}
else
{
TRACE( "else of avatar got cleared." );
// avatar got cleared just set the icon index to '0'
// icon what was added still remains in the listbox icon array
// dont delete the old icon, because that needs to modify the whole
// indexes of the other contacts.
// "keeping the icon is better than changing all contacts indexes"
// The icons will be deleted by listbox, when list box got destructed.
iArrayProcess.SetOwnAvatarIndexL( KErrNone );
}
}
else
{
TRACE( " else not own id" );
TRACE( " else not own id aUserId = %S",&aUserId );
TInt index = iArrayProcess.GetSelectedItemIndex( aUserId );//Get the index from storage.
TRACE( " after GetSelectedItemIndex" );
TPtrC8 avatardata = iArrayProcess.AvatarContent( index );
TRACE("after iArrayProcess.AvatarContent" );
Avindex = iArrayProcess.AvatarIndex(index);
TRACE( " after Avindex = %d",Avindex );
if( avatardata.Length() )
{
TRACE( "inside if avatardata.Length()" );
newIcon = AvatarToIconL( avatardata );
}
if( newIcon ) // there is a new avatar icon
{
TRACE( "inside if newIcon" );
CArrayPtr<CGulIcon>* currentIconArray = listBoxData->IconArray();
if( Avindex ) // if there is old icon already
{
TRACE( " inside Avindex" );
// delete the old icon compress the array and insert at the same position
currentIconArray->Delete( Avindex );
currentIconArray->Compress();
currentIconArray->InsertL( Avindex , newIcon);
}
else
{
TRACE( " inside Avindex else" );
// if there is no old icon append at the last
currentIconArray->AppendL( newIcon);
// set the index to cenrep
iArrayProcess.SetAvatarIndex(index, currentIconArray->Count()-1 );
}
}
else
{
TRACE( " avatar got cleared" );
// avatar got cleared just set the icon index to '0'
// icon what was added still remains in the listbox icon array
// dont delete the old icon, because that needs to modify the whole
// indexes of the other contacts.
// "keeping the icon is better than changing all contacts indexes"
// The icons will be deleted by listbox, when list box got destructed.
iArrayProcess.SetAvatarIndex( index , KErrNone );
}
}
iListBox->DrawNow();
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleAddition
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::HandleAdditionL(TVIMPSTEnums::TItem aType, TInt aIndex)
{
if(iListBox )
{
iListBox->HandleItemAdditionL();
UpdateViewL(aIndex,aType) ;
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleAddition
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::HandleDeletionL(TVIMPSTEnums::TItem aType , TInt aIndex )
{
TRACER_AUTO;
if(iListBox)
{
iListBox->HandleItemRemovalL();
TInt count = iListBox->Model()->NumberOfItems();
if( count == aIndex )
{
aIndex = 0;
}
UpdateViewL(aIndex,aType) ;
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleItemAdditionL
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::HandleItemAdditionL()
{
TRACER_AUTO;
if(iListBox)
{
iListBox->HandleItemAdditionL();
TInt index = CurrentItemIndex();
TVIMPSTEnums::TItem type = iArrayProcess.GetType(index);
UpdateViewL(index,type) ;
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleItemRemovalL
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::HandleItemRemovalL()
{
if(iListBox)
{
iListBox->HandleItemRemovalL();
TInt index = CurrentItemIndex();
TVIMPSTEnums::TItem type = iArrayProcess.GetType(index);
UpdateViewL(index,type) ;
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SizeChanged
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::SizeChanged()
{
SetLayout(); //layouting controls
if ( iFindbox && iFindPaneIsVisible )
{
iFindbox->MakeVisible( ETrue );
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::CountComponentControls
// --------------------------------------------------------------------------
//
TInt CVIMPSTUiDoubleListBoxTabViewControl::CountComponentControls() const
{
// return number of controls inside this container
if( !iFindbox )
{
// Find-pane does not exist when there is no data in listbox,
// so only one control exists (listbox)
return 1; //Ignore CodeScanner warning
}
else
{
// listbox and findbox exists. that makes it two
return 2; //Ignore CodeScanner warning
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::FocusChanged
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::FocusChanged( TDrawNow aDrawNow )
{
if ( iFindbox && iFindbox->IsVisible() )
{
iFindbox->SetFocus( IsFocused(), aDrawNow );
if ( aDrawNow == EDrawNow && IsFocused() )
{
iFindbox->DrawDeferred();
}
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::ComponentControl
// --------------------------------------------------------------------------
//
CCoeControl* CVIMPSTUiDoubleListBoxTabViewControl::ComponentControl(TInt aIndex) const
{
TRACER_AUTO;
// return iListBox;
switch ( aIndex )
{
// the caller wants to have the first control
// so it's always listbox
case 0:
{
return iListBox;
}
// the caller wants to have the second control
// so it's always the findbox if it exists
case 1:
{
if( iFindbox )
{
return iFindbox;
}
return NULL;
}
default:
{
return NULL;
}
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::OfferKeyEventL
// --------------------------------------------------------------------------
//
TKeyResponse CVIMPSTUiDoubleListBoxTabViewControl::OfferKeyEventL
(const TKeyEvent& aKeyEvent,TEventCode aType)
{
TRACER_AUTO;
if ( !aKeyEvent.iCode )
{
//The character code generated
//for an EEventKey, or 0 for a down or up event.
//For down or up key return key consumed.. handle only the events
if((EEventKeyDown == aType) && (EStdKeyDevice3 == aKeyEvent.iScanCode))
{
//for setting the command to be executed for the "Selection key"
//in case of selection key, container's OfferKeyEventL() is called only for EEventKeyDown and EEventKeyUp
//and not for EEventKey
UpdateCbaL();
}
return EKeyWasConsumed;
}
UpdateCbaL();
TKeyResponse ret = EKeyWasNotConsumed;
// Offer key event first to the key event handler
if ( iKeyEventHandler && iKeyEventHandler->Pbk2ProcessKeyEventL
( aKeyEvent, aType ) )
{
ret = EKeyWasConsumed;
}
switch ( aKeyEvent.iCode )
{
case EKeyBackspace:
{
if ( iFindbox )
{
if( iFindbox->TextLength() == 0 )
{
TInt index = CurrentItemIndex();
if( iArrayProcess.IsConversationExist(index) )
{
iTabbedView.CloseConversationL();
ret = EKeyWasConsumed;
}
else if(TVIMPSTEnums::EContactItem == iArrayProcess.GetType( index ) )
{
if( TVIMPSTEnums::ESVCERegistered == iArrayProcess.GetLoginState() )
{
iTabbedView.DeleteContactL();
}
ret = EKeyWasConsumed;
}
}
}
break;
}
// Case to handle send key press consumption.
case EKeyYes:
{
TInt index = iListBox->CurrentItemIndex();
if( TVIMPSTEnums::EOwnStatusItem == iArrayProcess.GetType( index ) )
{
ret = EKeyWasConsumed;
}
break;
}
default:
break;
}
if( EKeyPhoneSend == aKeyEvent.iCode && ret != EKeyWasConsumed )
{
if( iEngine.IsSubServiceSupportedL(TVIMPSTEnums::EVoip))
{
iTabbedView.MakeVoipCallL();
ret = EKeyWasConsumed;
}
}
if( ret == EKeyWasConsumed )
{
// user might has choosen back/end key/application key etc
// application might switch to background
// return from here
return ret;
}
if (iFindPaneIsVisible && iFindbox )
{
ret = iFindbox->OfferKeyEventL( aKeyEvent, aType ) ;
}
// Not consumed by the key handler and findpane , offer to the control next
if ( ret == EKeyWasNotConsumed )
{
ret = iListBox->OfferKeyEventL( aKeyEvent, aType );
}
iTabbedView.UpdateToolbarL();
return ret;
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::CurrentItemIndex
// --------------------------------------------------------------------------
//
TInt CVIMPSTUiDoubleListBoxTabViewControl::CurrentItemIndex() const
{
TRACER_AUTO;
if( !iListBox )
{
return KErrNotFound;
}
if( !iListBox->View() )
{
// CurrentItemIndex panics if the listbox has no view
return KErrNotFound;
}
TInt curIndex( iListBox->CurrentItemIndex() );
if ( curIndex < 0 )
{
return KErrNotFound;
}
CVIMPSTUiListBoxModel* model =
static_cast<CVIMPSTUiListBoxModel*>( iListBox->Model() );
if( model )
{
return model->FilteredItemIndex( curIndex );
}
return KErrNotFound;
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetCurrentItemIndex
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::SetCurrentItemIndex(TInt aIndex)
{
TRACER_AUTO;
if (iListBox->CurrentItemIndex() != aIndex &&
aIndex >= 0 &&
aIndex < iListBox->Model()->NumberOfItems() )
{
iListBox->SetCurrentItemIndex(aIndex);
TRAP_IGNORE(UpdateCbaL());
}
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetCurrentItemIndexAndDraw
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::SetCurrentItemIndexAndDraw(TInt aIndex)
{
SetCurrentItemIndex(aIndex);
this->DrawDeferred();
}
// --------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetListEmptyTextL
// --------------------------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::SetListEmptyTextL(TInt aResourceId)
{
HBufC* msgText;
TRACER_AUTO;
// Get Service Name from Engine , load string from resource and display.
// This text is shown to tell the user to restart phone to get the service again.
TPtrC serviceNamePtr(iEngine.ServiceName());
msgText = StringLoader::LoadLC(aResourceId, serviceNamePtr, iCoeEnv);
iListBox->View()->SetListEmptyTextL(*msgText);
TRACE("Display Text %S", msgText );
CleanupStack::PopAndDestroy(msgText);
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::LoadBitmapsL
// Called by framework when the view size is changed
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::LoadBitmapsL()
{
TRACER_AUTO;
CFormattedCellListBoxData* listBoxData = iListBox->ItemDrawer()->ColumnData();
if ( !listBoxData )
{
//No listbox data
User::Leave( KErrNotFound );
}
CAknIconArray* icons = iBrandHandler.LoadIconsLC( );
CArrayPtr<CGulIcon>* oldIconArray = listBoxData->IconArray();
if( oldIconArray )
{
oldIconArray->ResetAndDestroy();
delete oldIconArray;
listBoxData->SetIconArray( NULL );
}
TPtrC8 avatardata = iArrayProcess.OwnAvatarContentL();
CGulIcon* newIcon = NULL;
if( avatardata.Length() )
{
newIcon = AvatarToIconL( avatardata );
}
if( newIcon )
{
// if icon creation from avatar is successful then append icon
// set the index
icons->AppendL(newIcon);
iArrayProcess.SetOwnAvatarIndexL( icons->Count()-1 );
}
else
{ // set the index to '0'
// index=0 means default icon
iArrayProcess.SetOwnAvatarIndexL( KErrNone );
}
TInt count = iArrayProcess.Count();
// loop all the items in the array and get the avatar data
for (TInt i=0 ;i< count ;++i)
{
TPtrC8 avatarContent = iArrayProcess.AvatarContent(i);
newIcon = NULL;// make this as NULL since the icon
//ownership will be taken from LIstbox
if( avatarContent.Length())
{
// if that contact has any avatar data then process and create the icon
newIcon = AvatarToIconL( avatarContent );
}
if ( newIcon )
{
// if the icon is created successfully the append to icon array
icons->AppendL(newIcon);
// set the icon index to the storage
iArrayProcess.SetAvatarIndex( i , icons->Count()-1);
}
else
{
//if icon not found. set the default for buddies
iArrayProcess.SetAvatarIndex( i , KErrNone);
}
}
// Set icon-array to listbox's drawer
listBoxData->SetIconArray( icons );
CleanupStack::Pop( icons );
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleListBoxEventL(
// CEikListBox* /*aListBox*/, TListBoxEvent /*aEventType*/ )
// From MEikListBoxObserver, Handles event's generated by listbox
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::HandleListBoxEventL(
CEikListBox* /*aListBox*/, TListBoxEvent aEventType )
{
TRACER_AUTO;
iTabbedView.UpdateToolbarL();
switch(aEventType)
{
case EEventItemSingleClicked:
{
TInt index = CurrentItemIndex();
TVIMPSTEnums::TItem itemType = iArrayProcess.GetType(index);
TBool presenceEnabled = iEngine.IsSubServiceEnabled(TVIMPSTEnums::EPresence);
TBool imEnabled = iEngine.IsSubServiceEnabled(TVIMPSTEnums::EIM);
TBool voipEnabled = iEngine.IsSubServiceEnabled(TVIMPSTEnums::EVoip);
TVIMPSTEnums::TVIMPSTRegistrationState serviceState = iTabbedView.GetServiceState();
TVIMPSTEnums::TOnlineStatus onlinestatus = iArrayProcess.GetOnlineStatusL(index);
if(TVIMPSTEnums::EOwnStatusItem == itemType &&
TVIMPSTEnums::ESVCENotRegistered == serviceState)
{
iTabbedView.HandleCommandL( ECmdLogin );
}
else if(TVIMPSTEnums::EOwnStatusItem == itemType &&
TVIMPSTEnums::ESVCEWaitingForNetwork == serviceState)
{
iTabbedView.HandleCommandL( ECmdChangeConnectioninWaitingState);
}
else if(TVIMPSTEnums::EOwnStatusItem == itemType
&& presenceEnabled &&
TVIMPSTEnums::ESVCERegistered == serviceState )
{
iTabbedView.HandleCommandL( ECmdChangeStatus );
}
else if( ( TVIMPSTEnums::EContactItem == itemType ||
TVIMPSTEnums::EUnknonContactItem == itemType )&& imEnabled &&
TVIMPSTEnums::ESVCERegistered == serviceState &&
TVIMPSTEnums::EServiceOut != onlinestatus )
{
iTabbedView.HandleCommandL( ECmdOpenConversation );
}
else if ( itemType == TVIMPSTEnums::EFriendRequestItem
&& TVIMPSTEnums::ESVCERegistered == serviceState)
{
iTabbedView.HandleCommandL( ECmdOpenFriendRequest );
}
else if( TVIMPSTEnums::EContactItem == itemType )
{
if((TVIMPSTEnums::EPending != onlinestatus) &&
!(TVIMPSTEnums::ESVCEUpdatingContacts == serviceState ||
TVIMPSTEnums::ESVCENetworkConnecting == serviceState ||
TVIMPSTEnums::ESVCENetworkDisConnecting == serviceState))
{
iTabbedView.HandleCommandL( ECmdContactDetails );
}
}
break;
}
// Add enter key handling
case EEventEnterKeyPressed:
{
CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
TInt commandId( iCba->ButtonGroup()->CommandId( CEikButtonGroupContainer::EMiddleSoftkeyPosition));
iTabbedView.HandleCommandL(commandId);
break;
}
default:
{
break;
}
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SendMessageL(
// CEikListBox* /*aListBox*/, TListBoxEvent /*aEventType*/ )
// From MEikListBoxObserver, Handles event's generated by listbox
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::SendMessageL()
{
TRACER_AUTO;
// TInt index = iListBox->CurrentItemIndex();
TInt index = CurrentItemIndex();
if( index< 0 )
{
// return if item not found
return;
}
TPtrC seletctedItem = iArrayProcess.GetItemUserId(index) ;
if(seletctedItem.Length())
{
TInt result = EAknSoftkeyOk;
//get the status from engine.
TVIMPSTEnums::TOnlineStatus status = iArrayProcess.GetOnlineStatusL(index);
if( status == TVIMPSTEnums::EOffline )
{
TBool isConvExist = iArrayProcess.IsConversationExist(index);
if( !isConvExist)
{
// TODO : need to show only once if conversation not exist
// handling of error message need to be done in cv also ,waiting for ximp changes
// Show note about offline contact
HBufC* msg = StringLoader::LoadLC(
R_QTN_CHAT_CONTACT_MAY_NOT_RECEIVE_MESSAGE,
seletctedItem );
result = VIMPSTUtilsDialog::DisplayQueryDialogL(
R_CHAT_CONTACT_MAY_NOT_RECEIVE_MESSAGE_DIALOG,
msg->Des() );
CleanupStack::PopAndDestroy( msg );
}
}
if( ( result == EAknSoftkeyOk ) || ( result == EAknSoftkeyYes ) )
{
TPtrC itemName = iArrayProcess.GetItemNameText(index) ;
// not own this p
MVPbkContactLink* contactLink = iArrayProcess.ContactLink( index );
TVwsViewId activeViewId;
CCoeEnv::Static()->AppUi()->GetActiveViewId( activeViewId );
UpdateCbaL();
// imlauncher call for luanching the conversationview with seletced user id
IMCVLauncher::LaunchImConversationViewL(activeViewId, iServiceId, seletctedItem, itemName, contactLink);
}
}
else
{
//When there is no XSP Id present it comes to here
//Displaying a note that there is no XSP ID
HBufC* note = NULL;
note = StringLoader::LoadLC( R_QTN_SERVTAB_NOXSP_ERROR );
VIMPSTUtilsDialog::DisplayNoteDialogL( *note );
CleanupStack::PopAndDestroy( note );
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::UpdateViewL
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::UpdateViewL(
TInt aIndex, TVIMPSTEnums::TItem aType)
{
TRACER_AUTO;
TInt index = KErrNotFound;
if( aIndex < 0 )
{
aIndex = CurrentItemIndex()<0?0:CurrentItemIndex();
}
switch(aType)
{
case TVIMPSTEnums::EContactItem:
case TVIMPSTEnums::EOwnStatusItem:
{
/*Not attempting to get the index of contact because aIndex is the
same as this index and we pass it on to the contactlistboxmodel's
visibleitem method*/
CVIMPSTUiListBoxModel* list =
static_cast<CVIMPSTUiListBoxModel*>( iListBox->Model() );
index = list->VisibleItemIndex(aIndex);
if( index != KErrNotFound && iFindbox )
{
if(iClrFindPaneFlag)
{
iFindbox->SetSearchTextL( KNullDesC );
iFindbox->DrawNow();
iClrFindPaneFlag = EFalse;
}
else
{
TBuf<KTextLimit> temp;
iFindbox->GetSearchText(temp);
if(0 != temp.Compare(KNullDesC))
{
((CAknFilteredTextListBoxModel*) iListBox->Model() )
->Filter()->HandleOfferkeyEventL();
}
}
}
break;
}
default:
{
//nothing to do
break;
}
}
iListBox->DrawNow();
SetCurrentItemIndex(aIndex);
SetFocusAndMakeItemVisible();
TInt count = iArrayProcess.Count();
if(count > KMinContact && ! iFindPaneIsVisible)
{
ActivateFindPaneL();
}
else if(count <= KMinContact && iFindPaneIsVisible) // extra check needed here to improve performance
{
DeactivateFindPaneL();
}
//Update the Toolbar after moving the focus to the current item.
iTabbedView.UpdateToolbarL();
UpdateCbaL();
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::ActivateFindPaneL()
// Activates find-pane
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::ActivateFindPaneL()
{
TRACER_AUTO;
if( !iFindbox )
{
// Use EAdaptiveSearch so that we can search according to columns.
iFindbox = CAknSearchField::NewL( *this,
CAknSearchField::EAdaptiveSearch,
NULL, KTextLimit );
// This is to filter the presence status from the search
// username(0)/presencestatus(1) - 1 is to filter the presence status
// column out of the search. In this case there are only two columns.
TBitFlags32 columnFilterFlag;
columnFilterFlag.Set(1);
iFindbox->SetListColumnFilterFlags(columnFilterFlag);
static_cast<CAknFilteredTextListBoxModel*>( iListBox->Model() )
->CreateFilterL( iListBox, iFindbox );
}
iFindbox->SetObserver( this );
iFindbox->ActivateL();
iFindbox->ResetL();
iFindbox->SetSearchTextL( KNullDesC );
iFindPaneIsVisible = ETrue;
SetLayout();
if( IsActivated() )
{
iFindbox->MakeVisible( ETrue );
iFindbox->SetFocus( ETrue );
iListBox->SizeChanged();
DrawNow();
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::DeactivateFindPaneL()
// De-activates find-pane
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::DeactivateFindPaneL()
{
TRACER_AUTO;
if( !iFindbox )
{
return;
}
static_cast<CAknFilteredTextListBoxModel*>( iListBox->Model() )
->Filter()->ResetFilteringL();
iFindbox->MakeVisible( EFalse );
iFindbox->SetFocus( EFalse );
iFindPaneIsVisible = EFalse;
SetLayout();
if( IsActivated() )
{
DrawNow();
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::GetFocussedId()
// To get the pointer to the iFocussedID
// ---------------------------------------------------------
TPtrC CVIMPSTUiDoubleListBoxTabViewControl::GetFocussedId()
{
TInt index = CurrentItemIndex();
if( index < 0 )
{
index = 0;
}
return iCommandHandler.GetProcessInterface().GetItemUserId( index );
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetFocussedId()
// Saves the Contact ID in iFocussedID
// ---------------------------------------------------------
void CVIMPSTUiDoubleListBoxTabViewControl::SetFocussedId(const TDesC& aContact)
{
TInt index = iCommandHandler.GetProcessInterface().GetSelectedItemIndex( aContact );
if( index < 0 )
{
index = 0;
}
SetCurrentItemIndex( index );
SetFocusAndMakeItemVisible();
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetLayout()
// Layouts current components according to AVKON LAF
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::SetLayout()
{
TRACER_AUTO;
const TRect rect( Rect() );
if( iListBox && iFindPaneIsVisible )
{
TAknWindowLineLayout empty;
empty.iC = 0;
empty.il = 0;
empty.it = 0;
empty.ir = 0;
empty.ib = 0;
empty.iW = ELayoutEmpty;
empty.iH = ELayoutEmpty;
TAknWindowLineLayout findPane = AknLayoutScalable_Avkon::find_pane().LayoutLine();
TAknWindowLineLayout listPane;
// listPane should equal to parent's rect
listPane.il = Rect().iTl.iX;
listPane.ir = ELayoutEmpty;
listPane.it = Rect().iTl.iY;
listPane.ib = ELayoutEmpty;
// this check is required since it's not guaranteed that listbox's SetRect
// has been called when this code is executed
if ( Size().iWidth > 0 )
{
listPane.iW = Size().iWidth;
listPane.ir = ELayoutEmpty;
}
else
{
listPane.iW = ELayoutEmpty;
listPane.ir = 0;
}
// but findpane's height should be subtracted
listPane.iH = Size().iHeight - findPane.iH;
// findPane's width should equal to listPane's width
findPane.iW = listPane.iW;
CAknFilteredTextListBoxModel* m = static_cast <CAknFilteredTextListBoxModel*> ( iListBox->Model() );
if ( m->Filter() )
{
m->Filter()->SetParentControl( this );
}
TAknLayoutRect lrect;
lrect.LayoutRect( Rect(), empty );
AknLayoutUtils::LayoutControl( iFindbox, lrect.Rect(), findPane );
AknLayoutUtils::LayoutControl( iListBox, Rect(), listPane );
}
else if( iListBox )
{
AknLayoutUtils::LayoutControl( iListBox,
rect,
AKN_LAYOUT_WINDOW_list_gen_pane( 0 ) );
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleControlEventL
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::HandleControlEventL(CCoeControl* /*aControl*/,TCoeEvent aEventType)
{
// We only observe iFindbox
if( EEventStateChanged == aEventType )
{
((CAknFilteredTextListBoxModel*) iListBox->Model() )
->Filter()->HandleOfferkeyEventL();
}
iListBox->DrawNow();
iTabbedView.UpdateToolbarL();
}
// ---------------------------------------------------------
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::CheckAndSetLastItemFlag()
// Checks if the last contact is focused and Sets the iLastItemFlag
// ---------------------------------------------------------
void CVIMPSTUiDoubleListBoxTabViewControl::CheckAndSetLastItemFlag()
{
if(iListBox->CurrentItemIndex() == (iArrayProcess.Count() - 1))
{
iLastItemFlag = ETrue;
}
else
{
iLastItemFlag = EFalse;
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetFocusAndMakeItemVisible()
// Compares the Saved Contact in iFocussedID with the contacts in the List and focuses if it is found
// ---------------------------------------------------------
void CVIMPSTUiDoubleListBoxTabViewControl::SetFocusAndMakeItemVisible()
{
TRACER_AUTO;
TInt count = iArrayProcess.Count();
TInt index = CurrentItemIndex();
if( index == count )
{
if( iLastItemFlag )
{
index = count - 1;
iLastItemFlag = EFalse;
}
}
CVIMPSTUiListBoxModel* model =
static_cast<CVIMPSTUiListBoxModel*>( iListBox->Model() );
if( model )
{
index = model->VisibleItemIndex( index );
}
iListBox->ScrollToMakeItemVisible(index );
SetCurrentItemIndex(index);
iListBox->DrawDeferred();
}
// ---------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetClrFindPaneFlag(TBool aFlag)
// ---------------------------------------------------------------------
void CVIMPSTUiDoubleListBoxTabViewControl::SetClrFindPaneFlag(TBool aFlag)
{
iClrFindPaneFlag = aFlag;
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::CoeControl()
// ---------------------------------------------------------
CCoeControl* CVIMPSTUiDoubleListBoxTabViewControl::CoeControl()
{
return this; // return this pointer since its a parent class pointer of CCoeControl
}
// ------------------------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::AvatarToIconL
//
// ------------------------------------------------------------------------
CGulIcon* CVIMPSTUiDoubleListBoxTabViewControl::AvatarToIconL( const TDesC8& aAvatarContent )
{
TRACER_AUTO;
CGulIcon* newIcon = NULL;
CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();
CleanupStack::PushL( imageHandler );
// pass the avatar content and mimetype as NULL
// mimetype will be recognised by the UTILS class
HBufC8* content = imageHandler->ProcessImageFromDataL( aAvatarContent , KNullDesC8);
if ( iAvatarError == KErrNone)
{
newIcon = CGulIcon ::NewL( &(imageHandler->Bitmap()) );
newIcon->SetBitmapsOwnedExternally( EFalse );
}
CleanupStack::PopAndDestroy(); // imageHandler
if(content)
{
delete content;
content = NULL;
}
return newIcon;
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::SetCbaLockL()
// Sets the lock status of cba keys.
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::SetCbaLockL( TBool aLock )
{
iCbaLock = aLock;
if( !aLock )
{
UpdateCbaL();
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::UpdateCbaL()
// Updates Softkeys according to current focus.
// ---------------------------------------------------------
//
void CVIMPSTUiDoubleListBoxTabViewControl::UpdateCbaL( TBool aUseDefaultCba /*= EFalse*/ )
{
TRACER_AUTO;
TInt cbaRes = R_SERVTAB_SOFTKEYS_OPTIONS_EXIT__EMPTY;
iCurrentCmdToExe = -1;
if( !iCbaLock )
{
TInt index = CurrentItemIndex();
//if invalid index then dont set any command
if(KErrNotFound == index)
{
if ( iCba )
{
iCba->SetCommandSetL( cbaRes );
iCba->DrawNow();
}
return;
}
TVIMPSTEnums::TItem itemtype = iArrayProcess.GetType(index);
TVIMPSTEnums::TOnlineStatus onlinestatus = iCommandHandler.GetProcessInterface().GetOnlineStatusL(index);
TVIMPSTEnums::TVIMPSTRegistrationState servicestate = iEngine.ServiceState();
TBool updateinvalid( iLastFocusedItemType == TVIMPSTEnums::EInvalid );
if ( !iCba )
{
iCba = CEikButtonGroupContainer::Current();
}
// default softkeys
if(iCba)
{
if( aUseDefaultCba || updateinvalid )
{
if( aUseDefaultCba )
{
iLastFocusedItemType = TVIMPSTEnums::EOwnStatusItem;
}
else
{
iLastFocusedItemType = itemtype;
}
if ( itemtype == TVIMPSTEnums::EOwnStatusItem )
{
// Own status
if(TVIMPSTEnums::ESVCERegistered == servicestate)
{
// Options/Back/Change status
cbaRes = R_SERVTAB_SOFTKEYS_OPTIONS_EXIT__CHANGESTATUS;
iCurrentCmdToExe = ECmdChangeStatus;
}
else if(TVIMPSTEnums::ESVCENetworkConnecting == servicestate)
{
if(iTabbedView.CancelLoginSupportedL())
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTION_CANCEL__EXIT;
iCurrentCmdToExe = ECmdCancelLogin;
}
else
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTIONS_EXIT__EMPTY;
iCurrentCmdToExe = -1;
}
}
else if(TVIMPSTEnums::ESVCEWaitingForNetwork == servicestate)
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTION_CHANGECONN__EXIT;
iCurrentCmdToExe = ECmdChangeConnectioninWaitingState;
}
else if(TVIMPSTEnums::ESVCEUpdatingContacts != servicestate)
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTION_LOGIN__EXIT;
iCurrentCmdToExe = ECmdLogin;
}
}
iCba->SetCommandSetL( cbaRes );
iCba->DrawNow();
}
// collapse softkey ( when focus is on contact )
else if( itemtype == TVIMPSTEnums::EContactItem )
{
iLastFocusedItemType = itemtype;
if(TVIMPSTEnums::ESVCERegistered == servicestate)
{
// im is supported
if(iEngine.IsSubServiceSupportedL(TVIMPSTEnums::EIM))
{
iCba->SetCommandSetL( R_SERVTAB_SOFTKEYS_OPTION_OPENCONV__EXIT );
iCurrentCmdToExe = ECmdOpenConversation;
}
else //im is not supporteed
{
iCba->SetCommandSetL( R_SERVTAB_SOFTKEYS_OPTIONS_DETAILS__EXIT );
iCurrentCmdToExe = ECmdContactDetails;
}
}
else if(TVIMPSTEnums::ESVCENotRegistered == servicestate)
{
iCba->SetCommandSetL( R_SERVTAB_SOFTKEYS_OPTIONS_DETAILS__EXIT );
iCurrentCmdToExe = ECmdContactDetails;
}
iCba->DrawNow();
}
else if( itemtype == TVIMPSTEnums::EUnknonContactItem )
{
iLastFocusedItemType = itemtype;
if(TVIMPSTEnums::ESVCERegistered == servicestate &&
iEngine.IsSubServiceSupportedL(TVIMPSTEnums::EIM))
{
iCba->SetCommandSetL( R_SERVTAB_SOFTKEYS_OPTION_OPENCONV__EXIT );
iCurrentCmdToExe = ECmdOpenConversation;
}
else //im is not supporteed
{
iCba->SetCommandSetL( R_SERVTAB_SOFTKEYS_OPTIONS_EXIT__EMPTY );
iCurrentCmdToExe = -1;
}
iCba->DrawNow();
}
// Focus on own contact item
else if( itemtype == TVIMPSTEnums::EOwnStatusItem )
{
iLastFocusedItemType = itemtype;
if ( itemtype == TVIMPSTEnums::EOwnStatusItem )
{
// Own status
if(TVIMPSTEnums::ESVCERegistered == servicestate)
{
// Options/Back/Change status
cbaRes = R_SERVTAB_SOFTKEYS_OPTIONS_EXIT__CHANGESTATUS;
iCurrentCmdToExe = ECmdChangeStatus;
}
else if(TVIMPSTEnums::ESVCENetworkConnecting == servicestate)
{
if(iTabbedView.CancelLoginSupportedL())
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTION_CANCEL__EXIT;
iCurrentCmdToExe = ECmdCancelLogin;
}
else
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTIONS_EXIT__EMPTY;
iCurrentCmdToExe = -1;
}
}
else if(TVIMPSTEnums::ESVCEWaitingForNetwork == servicestate)
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTION_CHANGECONN__EXIT;
iCurrentCmdToExe = ECmdChangeConnectioninWaitingState;
}
else if(TVIMPSTEnums::ESVCEUpdatingContacts != servicestate)
{
cbaRes = R_SERVTAB_SOFTKEYS_OPTION_LOGIN__EXIT;
iCurrentCmdToExe = ECmdLogin;
}
}
//add for connecting state and waiting for connection state.
iCba->SetCommandSetL( cbaRes );
iCba->DrawNow();
}
// Focus on invitation item
else if( itemtype == TVIMPSTEnums::EFriendRequestItem )
{
iLastFocusedItemType = itemtype;
if(TVIMPSTEnums::ESVCERegistered == servicestate)
{
iCurrentCmdToExe = ECmdOpenFriendRequest;
iCba->SetCommandSetL( R_SERVTAB_SOFTKEYS_OPTION_OPENFRNDREQ__EXIT );
iCba->DrawNow();
}
}
}
}
}
// ---------------------------------------------------------
// CVIMPSTUiDoubleListBoxTabViewControl::HandleAvatarRefreshL()
// Saves the Contact ID in iFocussedID
// ---------------------------------------------------------
void CVIMPSTUiDoubleListBoxTabViewControl::HandleAvatarRefreshL( const TDesC& aUserId,TBool aBlock )
{
TRACER_AUTO;
if(aBlock)
{
TRACE("inside blocking");
TInt index = iArrayProcess.GetSelectedItemIndex(aUserId );//Get the index from storage.
if(index >= 0)
{
CFormattedCellListBoxData* listBoxData = iListBox->ItemDrawer()->ColumnData();
CArrayPtr<CGulIcon>* currentIconArray = listBoxData->IconArray();
TInt avIndex = iArrayProcess.AvatarIndex(index);
if( avIndex ) // if there is old icon already
{
// delete the old icon compress the array and insert at the same position
currentIconArray->Delete( avIndex );
currentIconArray->Compress();
}
// avatar got cleared just set the icon index to '0'
// icon what was added still remains in the listbox icon array
// dont delete the old icon, because that needs to modify the whole
// indexes of the other contacts.
// "keeping the icon is better than changing all contacts indexes"
// The icons will be deleted by listbox, when list box got destructed.
iArrayProcess.SetAvatarIndex( index , KErrNone );
}
}
else
{
TRACE("inside unblocking calling handleavatarchangel");
HandleAvatarChangeL(aUserId);
}
}
// End of File