1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  CMSFillRuleEditList class implementation

    15 *

    16 */

    17 

    18 

    19 #include <mediaservant.rsg>

    20 #include <barsread.h>

    21 #include <akntextsettingpage.h>

    22 #include <StringLoader.h>

    23 #include <akncheckboxsettingpage.h>

    24 #include <e32math.h>

    25 #include <utf.h>

    26 

    27 #include "cmsqlpropertycontainer.h"

    28 #include "mserv.hlp.hrh"

    29 #include "cmfillrule.h"

    30 #include "cmfillrulecontainer.h"

    31 #include "cmmediaserverfull.h"

    32 #include "msappui.h"

    33 #include "mediaservantuid.h"

    34 #include "msengine.h"

    35 #include "msconstants.h"

    36 #include "msfillruleeditlist.h"

    37 #include "msfillruleeditview.h"

    38 #include "msruleamountsetting.h"        // Amount

    39 #include "msruleserverssetting.h"       // Servers

    40 #include "msrulemultiselectionsetting.h"// Artist, genre, album, track

    41 #include "msrulefilesizesetting.h"      // File size (min/max)

    42 #include "mediaservant.hrh"

    43 #include "msmetadatacollector.h"

    44 #include "msdebug.h"

    45 #include "msfillcontainer.h"

    46 #include "msfillview.h"

    47 

    48 // CONSTANTS

    49 _LIT( KSpace, " ");

    50 const TInt KDateBufferLength = 20;

    51 

    52 

    53 // --------------------------------------------------------------------------

    54 // CMSFillRuleEditList::NewL()

    55 // Two phase constructor.

    56 // --------------------------------------------------------------------------

    57 //

    58 CMSFillRuleEditList* CMSFillRuleEditList::NewL(

    59                 CMSAppUi& aAppUi, CMSFillRuleEditView& aView )

    60     {

    61     LOG(_L("[MediaServant]\t CMSFillRuleEditList::NewL"));

    62 

    63     CMSFillRuleEditList* self = CMSFillRuleEditList::NewLC( aAppUi, aView );        

    64     CleanupStack::Pop( self );

    65     

    66     return self;

    67     }

    68 

    69 // --------------------------------------------------------------------------

    70 // CMSFillRuleEditList::NewLC()

    71 // Two phase constructor.

    72 // --------------------------------------------------------------------------

    73 //

    74 CMSFillRuleEditList* CMSFillRuleEditList::NewLC(

    75                 CMSAppUi& aAppUi, CMSFillRuleEditView& aView )

    76     {

    77     LOG(_L("[MediaServant]\t CMSFillRuleEditList::NewLC"));

    78 

    79     CMSFillRuleEditList* self = new ( ELeave ) CMSFillRuleEditList();

    80     CleanupStack::PushL( self );

    81     self->ConstructL( aAppUi, aView );

    82         

    83     return self;

    84     }

    85     

    86 // --------------------------------------------------------------------------

    87 // CMSFillRuleEditList::CMSFillRuleEditList()

    88 // --------------------------------------------------------------------------

    89 //

    90 CMSFillRuleEditList::CMSFillRuleEditList()

    91     {

    92     LOG(_L("[MediaServant]\t CMSFillRuleEditList::CMSFillRuleEditList"));

    93 

    94     iDummyText.Copy(_L(""));

    95     iMinFileSize = 0;

    96     iMaxFileSize = 0;

    97     iMinFileSizeSet = EMSAny;

    98     iMaxFileSizeSet = EMSAny;

    99     iFileSize = 0;

   100     iFileSizeEnum = 0;

   101     iTrackLengthEnum = 0;

   102     iNewList = EFalse;

   103     }

   104 

   105 // --------------------------------------------------------------------------

   106 // CMSFillRuleEditList::~CMSFillRuleEditList()

   107 // --------------------------------------------------------------------------

   108 //

   109 CMSFillRuleEditList::~CMSFillRuleEditList()

   110     {

   111     LOG(_L("[MediaServant]\t CMSFillRuleEditList::~CMSFillRuleEditList"));

   112 

   113     delete iMetadataCollector;

   114 

   115     if ( iServers )

   116         {

   117         iServers->ResetAndDestroy();

   118         iServers->Close();

   119         delete iServers;

   120         }

   121 

   122     if ( iServerArray )

   123         {

   124         iServerArray->ResetAndDestroy();

   125         delete iServerArray;

   126         }

   127 

   128     iVisibleRules.Close();

   129 

   130     iArtistArray.Close();

   131     iAlbumArray.Close();

   132     iGenreArray.Close();

   133     iTrackArray.Close();

   134     iVideoTitleArray.Close();

   135     

   136     }

   137 

   138 // --------------------------------------------------------------------------

   139 // CMSFillRuleEditList::ConstructL()

   140 // Second phase constructor.

   141 // --------------------------------------------------------------------------

   142 //

   143 void CMSFillRuleEditList::ConstructL( CMSAppUi& aAppUi,

   144                                       CMSFillRuleEditView& aView )

   145     {

   146     LOG(_L("[MediaServant]\t CMSFillRuleEditList::ConstructL"));

   147 

   148     iAppUi = &aAppUi;

   149     iView = &aView;

   150 

   151     // Set engine observer

   152     iAppUi->MSEngine()->SetObserver( this );

   153 

   154     // read template

   155     iRuleTemplate = iAppUi->ParameterAgent()->GetRuleTemplate();

   156 

   157     // Edit existing list

   158     if ( iRuleTemplate.templateType == EMSCmdEditRule )

   159         {

   160         // get selected item index from previous screen

   161         iSelectedList = iAppUi->ParameterAgent()->FillViewFocusIndex();

   162 

   163         // get selected list

   164         iRule =(*iAppUi->

   165                FillRuleController()->FillListArray())[iSelectedList]->List();

   166         // List media type

   167         iMediaType = iRule->MediaType();

   168 

   169         // set used template

   170         iRuleTemplate.selectedTemplate = iRule->TemplateId();

   171 

   172         ReadTemplateRulesL( iRuleTemplate.selectedTemplate );

   173         // Get values for rules

   174         GetRuleValuesL();

   175         }

   176 

   177     else

   178         {

   179         iNewList = ETrue;

   180 

   181         // New fill list will be last one - set focus index to it

   182         iSelectedList =

   183             iAppUi->FillRuleController()->FillListArray()->Count();

   184         iAppUi->ParameterAgent()->SetFillViewFocusIndex( iSelectedList );

   185 

   186         // Create new list

   187         iRule = CCmFillRule::NewL();

   188 

   189         // Read template rules and set default values

   190         ReadTemplateRulesL( iRuleTemplate.selectedTemplate );

   191 

   192         // Use template name as list name

   193         iListName.Copy( iRuleTemplate.templateName );

   194         HBufC8* temp = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

   195                                                             iListName );

   196         CleanupStack::PushL( temp );

   197         iRule->SetNameL( *temp );

   198         CleanupStack::PopAndDestroy( temp );

   199         // List type is determined by given menu command

   200         // MediaType is also set here

   201         SetListType( iRuleTemplate.templateType );

   202         iRule->SetTemplateId( iRuleTemplate.selectedTemplate );

   203 

   204         //Set rule selected by default

   205         iRule->SetSelected( ECmSelected );

   206 

   207         // Initialize fill rule status to ECmToBeFilled

   208         // If rule is image rule, status is re-set

   209         // according to used template

   210         iRule->SetStatus( ECmToBeFilled );

   211 

   212         InitializeValues();

   213 

   214         // save new list

   215         iAppUi->FillRuleController()->AddRuleL( iRule );

   216 

   217         // Get list

   218         iRule = (*iAppUi->FillRuleController()->

   219                                     FillListArray())[iSelectedList]->List();

   220         }

   221      

   222      // should filter the vedio array when construct first time, only selected item can be construct

   223      if( iRule->MediaType() == ECmVideo )

   224         {

   225         // reset track array

   226         iTrackArray.Reset();

   227         // append the select video title in track array

   228         TInt count = iVideoTitleArray.Count();

   229         if( count > 0 )

   230             {

   231             for( TInt i=0; i<count; i++ )

   232                 {

   233                 iTrackArray.AppendL( iVideoTitleArray[i] );	

   234                 }

   235             }

   236         	

   237         }

   238     // Creates metadata collector and starts data fetching

   239     iMetadataCollector = CMSMetadataCollector::NewL( *iAppUi,

   240                                                      iMediaType,

   241                                                      iGenreArray,

   242                                                      iArtistArray,

   243                                                      iAlbumArray,

   244                                                      iTrackArray);

   245 

   246     // get mediaservers and remove not activated

   247     GetServersAndCheckActivityL();

   248 

   249     CreateServerSettingListL();

   250     // Construct setting list

   251     ConstructListAndStartDataReadingL();

   252     

   253     iPreviousRuleIdentifier = 0;

   254     }

   255 

   256 // --------------------------------------------------------------------------

   257 // CMSFillRuleEditList::StartDataReadingL

   258 // starts reading data to multiselection lists from server

   259 // --------------------------------------------------------------------------

   260 //

   261 void CMSFillRuleEditList::ConstructListAndStartDataReadingL()

   262     {

   263     LOG(_L("[MediaServant]\t CMSFillRuleEditList::\

   264     ConstructListAndStartDataReadingL"));

   265 

   266     switch ( iMediaType )

   267         {

   268         case ECmVideo:

   269             {

   270              // construct item list

   271             CAknSettingItemList::ConstructFromResourceL(

   272                                             R_MS_VIDEO_FILL_RULES );

   273             break;

   274             }

   275         case ECmImage:

   276             {

   277              // construct item list

   278             CAknSettingItemList::ConstructFromResourceL(

   279                                             R_MS_IMAGE_FILL_RULES );

   280             if ( iNewList )

   281                 {

   282                 SaveListValuesL();

   283                 iAppUi->FillRuleController()->SaveRulesL();

   284                 PreprocessListL();

   285                 }

   286             else

   287                 {

   288                 CreateAndSetNaviPaneTextL();

   289                 }

   290             break;

   291             }

   292         case ECmAudio:

   293             {

   294              // construct item list

   295             CAknSettingItemList::ConstructFromResourceL(

   296                                             R_MS_AUDIO_FILL_RULES );

   297             break;

   298             }

   299         default:

   300             {

   301             break;

   302             }

   303         }

   304 

   305     if ( iMediaType == ECmVideo || iMediaType == ECmAudio )

   306         {

   307         // Show 'reading data' text on navi pane

   308         HBufC* naviText = StringLoader::LoadLC(

   309                                             R_MS_WAIT_GETTING_DATA_TEXT );

   310         iView->SetNavigationPaneTextL( *naviText );

   311         CleanupStack::PopAndDestroy( naviText );

   312         }

   313 

   314     }

   315 

   316 // --------------------------------------------------------------------------

   317 // CMSFillRuleEditList::SaveListValuesL

   318 // Saves list values from visible setting items

   319 // --------------------------------------------------------------------------

   320 //

   321 void CMSFillRuleEditList::SaveListValuesL()

   322     {

   323     LOG(_L("[MediaServant]\t CMSFillRuleEditList::SaveListValuesL"));

   324 

   325     CAknSettingItemArray* itemArray = SettingItemArray();

   326     for ( TInt index  = 0; index < itemArray->Count(); index++ )

   327         {

   328         CAknSettingItem* item = itemArray->At( index );

   329         if ( !item->IsHidden() )

   330             {

   331             SaveValueL( item );

   332             }

   333         }

   334     }

   335 

   336 // --------------------------------------------------------------------------

   337 // CMSFillRuleEditList::PreprocessListL

   338 // starts list preprocess and shows info on navi pane

   339 // --------------------------------------------------------------------------

   340 //

   341 void CMSFillRuleEditList::PreprocessListL()

   342     {

   343     LOG(_L("[MediaServant]\t CMSFillRuleEditList::PreprocessListL"));

   344 

   345     iAppUi->MSEngine()->PreProcessFillListL( iRule->Name() );

   346     HBufC* naviText = StringLoader::LoadLC( R_MS_PREPROCESSING_TEXT );

   347     iView->SetNavigationPaneTextL( *naviText );

   348     CleanupStack::PopAndDestroy( naviText );

   349     }

   350 

   351 // --------------------------------------------------------------------------

   352 // CMSFillRuleEditList::SaveValueL

   353 // Save values to rule container

   354 // Only values from visible rules are stored

   355 // --------------------------------------------------------------------------

   356 //

   357 void CMSFillRuleEditList::SaveValueL( CAknSettingItem* aItem )

   358     {

   359     LOG(_L("[MediaServant]\t CMSFillRuleEditList::SaveValueL"));

   360 

   361     if ( !aItem->IsHidden() )

   362         {

   363         switch ( aItem->Identifier() )

   364             {

   365             case EMSListName:

   366                 {

   367                 // Name is always visible - set rule name

   368                 HBufC8* listName =

   369                     CnvUtfConverter::ConvertFromUnicodeToUtf8L(

   370                        SettingItemArray()->At(EMSListName)->SettingTextL() );

   371                 CleanupStack::PushL( listName );

   372                 iRule->SetNameL( *listName );

   373                 CleanupStack::PopAndDestroy( listName );

   374                 break;

   375                 }

   376             case EMSShrinkImages:

   377                 {

   378                 // Set shrinking status for images

   379                 SetShrinkingStatus();

   380                 break;

   381                 }

   382             case EMSAmount:

   383                 {

   384                 // set amount of files

   385                 iRule->SetAmount( iAmount );

   386                 // set limit type

   387                 iRule->SetLimitType( iLimitType );

   388                 break;

   389                 }

   390             case EMSStartingWith:

   391                 {

   392                 iRule->SetMethod(

   393                             static_cast<TCmFillMethod> (iStartWith) );

   394                 break;

   395                 }

   396             case EMSDateFrom:

   397                 {

   398                 DeleteRule( ECmDate, ECmGreater );

   399 

   400                 TInt ruleIndex = iRule->AddRuleL( ECmDate,

   401                                                   ECmGreater );

   402                 HBufC8* str = HBufC8::NewL( KDateBufferLength );

   403                 CleanupStack::PushL( str );

   404                 str->Des().AppendNum(iDateFrom.Int64());

   405                 iRule->AddRuleParamL( ruleIndex, *str );

   406                 CleanupStack::PopAndDestroy( str );

   407                 break;

   408                 }

   409             case EMSDateUntil:

   410                 {

   411                 DeleteRule( ECmDate, ECmSmaller );

   412 

   413                 TInt ruleIndex = iRule->AddRuleL( ECmDate,

   414                                                   ECmSmaller );

   415                 HBufC8* str = HBufC8::NewL( KDateBufferLength );

   416                 CleanupStack::PushL( str );

   417                 str->Des().AppendNum(iDateUntil.Int64());

   418                 iRule->AddRuleParamL( ruleIndex, *str );

   419                 CleanupStack::PopAndDestroy( str );

   420 

   421                 break;

   422                 }

   423             case EMSServers:

   424                 {

   425                 HandleServerSelectionL();

   426                 break;

   427                 }

   428             case EMSFreeText:

   429                 {

   430                 DeleteRule( ECmFreeText );

   431                 if ( iFreeText.Size() )

   432                     {

   433                     TInt ruleIndex = iRule->AddRuleL( ECmFreeText,

   434                                                       ECmConsistOf );

   435                     HBufC8* str = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

   436                                                                  iFreeText );

   437                     CleanupStack::PushL( str );

   438                     iRule->AddRuleParamL( ruleIndex, *str );

   439                     CleanupStack::PopAndDestroy( str );

   440                     }

   441                 break;

   442                 }

   443             case EMSTitleName:

   444                 {

   445                 DeleteRule( ECmTitle );

   446 

   447                 if ( iVideoTitleArray.Count() > 0 )

   448                     {

   449                     AddAdditionalRuleL( iVideoTitleArray,

   450                                         ECmTitle,

   451                                         ECmEquals );

   452                     }

   453                 break;

   454                 }

   455             case EMSMinFileSize:

   456                 {

   457                 DeleteRule( ECmFileSize, ECmGreater );

   458                 if ( iMinFileSizeSet == EMSSetSize )

   459                     {

   460                     AddAdditionalRuleL( ECmFileSize,

   461                                         ECmGreater,

   462                                         iMinFileSize*KMega );

   463                     }

   464                 break;

   465                 }

   466             case EMSMaxFileSize:

   467                 {

   468                 DeleteRule( ECmFileSize, ECmSmaller );

   469                 if ( iMaxFileSizeSet == EMSSetSize )

   470                     {

   471                     AddAdditionalRuleL( ECmFileSize,

   472                                         ECmSmaller,

   473                                         iMaxFileSize*KMega );

   474                     }

   475                 break;

   476                 }

   477              case EMSGenre:

   478                 {

   479                 DeleteRule( ECmGenre );

   480 

   481                 if ( iGenreArray.Count() > 0 )

   482                     {

   483                     AddAdditionalRuleL( iGenreArray,

   484                                         ECmGenre,

   485                                         ECmEquals );

   486                     }

   487                 break;

   488                 }

   489              case EMSArtist:

   490                 {

   491                 DeleteRule( ECmArtist );

   492 

   493                 if ( iArtistArray.Count() > 0 )

   494                     {

   495                     AddAdditionalRuleL( iArtistArray,

   496                                         ECmArtist,

   497                                         ECmEquals );

   498                     }

   499                 break;

   500                 }

   501              case EMSAlbum:

   502                 {

   503                 DeleteRule( ECmAlbum );

   504 

   505                 if ( iAlbumArray.Count() > 0 )

   506                     {

   507                     AddAdditionalRuleL( iAlbumArray,

   508                                         ECmAlbum,

   509                                         ECmEquals );

   510                     }

   511                 break;

   512                 }

   513             case EMSTrack:

   514                 {

   515                 DeleteRule( ECmTitle );

   516 

   517                 if ( iTrackArray.Count() > 0 )

   518                     {

   519                     AddAdditionalRuleL( iTrackArray,

   520                                         ECmTitle,

   521                                         ECmEquals );

   522                     }

   523                 break;

   524                 }

   525             case EMSTrackLength:

   526                 {

   527                 DeleteRule( ECmDuration );

   528                 if ( iTrackLengthEnum )

   529                     {

   530                     SaveTrackDurationL();

   531                     }

   532                 break;

   533                 }

   534             case EMSFileSize:

   535                 {

   536                 DeleteRule( ECmFileSize );

   537                 if ( iFileSizeEnum )

   538                     {

   539                     SaveTrackFileSizeL();

   540                     }

   541                 break;

   542                 }

   543             default:

   544                 {

   545                 LOG(_L("[MediaServant]\t CMSFillRuleEditList::SaveValueL \

   546                 no such rule"));

   547                 break;

   548                 }

   549             }

   550         }

   551     }

   552 

   553 // --------------------------------------------------------------------------

   554 // CAknSettingItem* CMSFillRuleEditList::CreateSettingItemL(TInt aIdentifier)

   555 // Takes care of creating actual setting items.

   556 // --------------------------------------------------------------------------

   557 //

   558 CAknSettingItem* CMSFillRuleEditList::CreateSettingItemL( TInt aIdentifier )

   559     {

   560     CAknSettingItem* settingItem = NULL;

   561 

   562     // setting item is created according to aIdentifier

   563     switch ( aIdentifier )

   564         {

   565         case EMSListName:

   566             {

   567             settingItem = new (ELeave ) CMSTextSettingItem(

   568                                         aIdentifier,

   569                                         iListName );

   570             break;

   571             }

   572         case EMSShrinkImages:

   573             {

   574             settingItem = new (ELeave ) CMSEnumeratedTextPopupSettingItem(

   575                                   aIdentifier,

   576                                   reinterpret_cast<TInt&> (iShrinkImages) );

   577             break;

   578             }

   579 

   580         case EMSAmount:

   581             {

   582             settingItem = new (ELeave ) CMSRuleAmountSetting(

   583                                         aIdentifier,

   584                                         reinterpret_cast<TInt&> (iLimitType),

   585                                         iAmount );

   586             break;

   587             }

   588 

   589         case EMSStartingWith:

   590             {

   591             settingItem = new (ELeave ) CMSEnumeratedTextPopupSettingItem(

   592                                         aIdentifier,

   593                                         iStartWith );

   594             break;

   595             }

   596 

   597         case EMSDateFrom:

   598             {

   599             settingItem = new (ELeave ) CMSTimeOrDateSettingItem(

   600                                         R_MS_FILL_RULE_DATE_FROM_SETTING_PAGE,

   601                                         aIdentifier,

   602                                         CAknTimeOrDateSettingItem::EDate,

   603                                         iDateFrom );

   604             break;

   605             }

   606 

   607         case EMSDateUntil:

   608             {

   609             settingItem = new (ELeave ) CMSTimeOrDateSettingItem(

   610                                         R_MS_FILL_RULE_DATE_UNTIL_SETTING_PAGE,

   611                                         aIdentifier,

   612                                         CAknTimeOrDateSettingItem::EDate,

   613                                         iDateUntil );

   614             break;

   615             }

   616 

   617         case EMSServers:

   618             {

   619             settingItem = CMSRuleServersSetting::NewL(

   620                                                 aIdentifier,

   621                                                 *iServerArray,

   622                                                 iSettingText,

   623                                                 R_MS_VALUE_LIST_ANY_SOURCE_DEVICE);

   624             break;

   625             }

   626 

   627         case EMSFreeText:

   628             {

   629             settingItem = new (ELeave ) CMSTextSettingItem(

   630                                         aIdentifier,

   631                                         iFreeText );

   632             break;

   633             }

   634         case EMSTitleName:

   635             {

   636             settingItem = CMSRuleMultiselectionSetting::NewL(

   637                                                 aIdentifier,

   638                                                 R_MS_RULE_NAME_SETTING,

   639                                                 R_MS_VALUE_ANY_NAME,

   640                                                 R_MS_VALUE_LIST_ANY_NAME,

   641                                                 iMetadataCollector->Tracks(),

   642                                                 &iVideoTitleArray,

   643                                                 R_MS_RULE_TITLE_ITEM_TEXT,

   644                                                 iSettingText );

   645             break;

   646             }

   647 

   648         case EMSMinFileSize:

   649             {

   650             settingItem = new (ELeave ) CMSRuleFileSizeSetting(

   651                                         aIdentifier,

   652                                         EMSMinFileSize,

   653                                         iMinFileSizeSet,

   654                                         iMinFileSize );

   655             break;

   656             }

   657 

   658         case EMSMaxFileSize:

   659             {

   660             settingItem = new (ELeave ) CMSRuleFileSizeSetting(

   661                                         aIdentifier,

   662                                         EMSMaxFileSize,

   663                                         iMaxFileSizeSet,

   664                                         iMaxFileSize );

   665             break;

   666             }

   667 

   668         case EMSGenre:

   669             {

   670 

   671 

   672             settingItem = CMSRuleMultiselectionSetting::NewL(

   673                                                 aIdentifier,

   674                                                 R_MS_RULE_GENRE_SETTING,

   675                                                 R_MS_VALUE_ANY_GENRE,

   676                                                 R_MS_VALUE_LIST_ANY_GENRE,

   677                                                 iMetadataCollector->Genres(),

   678                                                 &iGenreArray,

   679                                                 R_MS_RULE_GENRE_ITEM_TEXT,

   680                                                 iSettingText );

   681             break;

   682             }

   683 

   684         case EMSArtist:

   685             {

   686             settingItem = CMSRuleMultiselectionSetting::NewL(

   687                                                 aIdentifier,

   688                                                 R_MS_RULE_ARTIST_SETTING,

   689                                                 R_MS_VALUE_ANY_ARTIST,

   690                                                 R_MS_VALUE_LIST_ANY_ARTIST,

   691                                                 iMetadataCollector->Artists(),

   692                                                 &iArtistArray,

   693                                                 R_MS_RULE_ARTIST_ITEM_TEXT,

   694                                                 iSettingText );

   695             break;

   696             }

   697 

   698         case EMSAlbum:

   699             {

   700             settingItem = CMSRuleMultiselectionSetting::NewL(

   701                                                 aIdentifier,

   702                                                 R_MS_RULE_ALBUM_SETTING,

   703                                                 R_MS_VALUE_ANY_ALBUM,

   704                                                 R_MS_VALUE_LIST_ANY_ALBUM,

   705                                                 iMetadataCollector->Albums(),

   706                                                 &iAlbumArray,

   707                                                 R_MS_RULE_ALBUM_ITEM_TEXT,

   708                                                 iSettingText );

   709             break;

   710             }

   711 

   712         case EMSTrack:

   713             {

   714             settingItem = CMSRuleMultiselectionSetting::NewL(

   715                                                 aIdentifier,

   716                                                 R_MS_RULE_TRACK_SETTING,

   717                                                 R_MS_VALUE_ANY_TRACK,

   718                                                 R_MS_VALUE_LIST_ANY_TRACK,

   719                                                 iMetadataCollector->Tracks(),

   720                                                 &iTrackArray,

   721                                                 R_MS_RULE_TRACK_ITEM_TEXT,

   722                                                 iSettingText );

   723             break;

   724             }

   725 

   726         case EMSTrackLength:

   727             {

   728             settingItem = new (ELeave ) CMSEnumeratedTextPopupSettingItem(

   729                                         aIdentifier,

   730                                         iTrackLengthEnum );

   731             break;

   732             }

   733 

   734          case EMSFileSize:

   735             {

   736             settingItem = new (ELeave ) CMSEnumeratedTextPopupSettingItem(

   737                                         aIdentifier,

   738                                         iFileSizeEnum );

   739             break;

   740             }

   741 

   742         case EMSAddMoreRules:

   743             {

   744             settingItem = new (ELeave ) CMSTextSettingItem(

   745                                         aIdentifier,

   746                                         iDummyText );

   747             break;

   748             }

   749         default:

   750             {

   751             LOG(_L("[MediaServant]\t CMSFillRuleEditList::CreateSettingItemL\

   752             item not found"));            

   753             break;

   754             }

   755         }

   756     return settingItem;

   757     }

   758 

   759 

   760 // --------------------------------------------------------------------------

   761 // CMSFillRuleEditList::OpenSelectedListboxItemL

   762 // --------------------------------------------------------------------------

   763 //

   764 void CMSFillRuleEditList::OpenSelectedListboxItemL()

   765     {

   766     LOG(_L("[MediaServant]\t CMSFillRuleEditList::\

   767     OpenSelectedListboxItemL"));

   768 

   769     HandleListBoxEventL( ListBox(), EEventEnterKeyPressed );

   770     }

   771 

   772 // --------------------------------------------------------------------------

   773 // CMSFillRuleEditList::HandleListBoxEventL()

   774 // Handles listbox events

   775 // --------------------------------------------------------------------------

   776 //

   777 void  CMSFillRuleEditList::HandleListBoxEventL ( CEikListBox *aListBox,

   778                                                  TListBoxEvent aEventType)

   779     {

   780     LOG(_L("[MediaServant]\t CMSFillRuleEditList::HandleListBoxEventL"));

   781 

   782     CAknSettingItemArray* itemArray = SettingItemArray();

   783     TInt currentItem = ListBox()->CurrentItemIndex();

   784     TInt realIndex = itemArray->ItemIndexFromVisibleIndex(currentItem);

   785     CAknSettingItem* item= (*itemArray)[realIndex];

   786 	

   787 	// Event type for non-touch UI

   788 	if ( aEventType == EEventEnterKeyPressed )

   789 		{

   790   		if ( item->Identifier() == EMSAddMoreRules )

   791 	        {

   792 	        AddFillRuleL();

   793 	        }

   794 	    else

   795         	{

   796         	CAknSettingItemList::HandleListBoxEventL ( aListBox, aEventType );

   797         	}

   798 		}

   799 	// Event type for touch UI

   800 	else if ( aEventType == EEventItemClicked )

   801 		{

   802 	    // show add fill rule query if last item "Add more rules" selected

   803 	    if ( item->Identifier() == EMSAddMoreRules &&

   804 	         iPreviousRuleIdentifier == EMSAddMoreRules )

   805      	   {

   806 	        AddFillRuleL();

   807 	        }

   808     	else

   809 	        {

   810 	        CAknSettingItemList::HandleListBoxEventL ( aListBox, aEventType );

   811     	    }

   812 		iPreviousRuleIdentifier = item->Identifier();

   813 	    // values need to be stored

   814 		StoreSettingsL();

   815 		}

   816     else if ( item->Identifier() != EMSAddMoreRules )

   817     	{

   818 		CAknSettingItemList::HandleListBoxEventL ( aListBox, aEventType );

   819     	}

   820     

   821     }

   822 

   823 // --------------------------------------------------------------------------

   824 // CMSFillRuleEditList::EditItemL()

   825 // Called by framework when item is opened

   826 // --------------------------------------------------------------------------

   827 //

   828 void  CMSFillRuleEditList::EditItemL (TInt aIndex, TBool aCalledFromMenu)

   829     {

   830     LOG(_L("[MediaServant]\t CMSFillRuleEditList::EditItemL"));

   831 

   832     // cancel ongoing operation

   833     iView->CancelAsyncOperation( iAppUi );

   834     iState = EMSIdle;

   835 

   836     CAknSettingItemList::EditItemL( aIndex, aCalledFromMenu );

   837 

   838     // get the item information after update

   839     CAknSettingItemArray* itemArray = SettingItemArray();

   840     TInt currentItem = ListBox()->CurrentItemIndex();

   841     TInt realIndex = itemArray->ItemIndexFromVisibleIndex(currentItem);

   842     CAknSettingItem* item= (*itemArray)[realIndex];

   843 

   844     // check if list name is modified

   845     if ( item->Identifier() == EMSListName )

   846         {

   847         HandleListNameL( item );

   848         }

   849 

   850     if ( CheckSettingPageAcceptance( item ) )

   851         {

   852         // store new value

   853         StoreSettingsL();

   854         // Save value to rule

   855         SaveValueL( item );

   856         // save rule and process it

   857         SaveAndPreprocesslistL( item );

   858         }

   859     }

   860 

   861 // --------------------------------------------------------------------------

   862 // CMSFillRuleEditList::HandleListNameL

   863 // Handles edit list name -case

   864 // --------------------------------------------------------------------------

   865 //

   866 void CMSFillRuleEditList::HandleListNameL( CAknSettingItem* aItem )

   867     {

   868     LOG(_L("[MediaServant]\t CMSFillRuleEditList::HandleListNameL"));

   869 

   870     CMSTextSettingItem* settingItem =

   871                             static_cast<CMSTextSettingItem*>( aItem );

   872 

   873     TPtr searchStr = settingItem->Text();

   874 

   875     // Deletes leading and trailing whitespace characters

   876     searchStr.Trim();

   877 

   878     HBufC* originalSearchStr =

   879                 CnvUtfConverter::ConvertToUnicodeFromUtf8L( iRule->Name() );

   880     CleanupStack::PushL( originalSearchStr );

   881 

   882     // whether they are same or not

   883     if ( *originalSearchStr != searchStr )

   884         {

   885         // if there are same names in other fill rules

   886         TBool isSame = CheckSameNameL( searchStr );

   887 

   888         if ( isSame )

   889             {

   890             TInt postfix = 0;

   891             TPtr itemText = searchStr;

   892 

   893             // decide which number is added to the end of the name

   894             for ( ; ; ++postfix )

   895                 {

   896                 HBufC* sameStr = HBufC::NewL( KMaxFileName );

   897                 CleanupStack::PushL( sameStr );

   898                 sameStr->Des().Append( itemText );

   899 

   900                 // if the name does not add number to the end is unique so keep the original name

   901                 if ( 0 != postfix)

   902                     {

   903                     sameStr->Des().Append( KSpace );

   904                     sameStr->Des().AppendNum( postfix );

   905                     // do number conversion

   906                     TPtr ptr = sameStr->Des();

   907                     AknTextUtils::

   908                      DisplayTextLanguageSpecificNumberConversion( ptr );

   909                     }

   910                 // must modify name with append a number

   911                 if ( !CheckSameNameL( *sameStr ) || ( *sameStr == *originalSearchStr ) )

   912                     {

   913                     CleanupStack::PopAndDestroy( sameStr );

   914                     break;

   915                     }

   916                 CleanupStack::PopAndDestroy( sameStr );

   917                 }

   918 

   919             // do not need append a number

   920             if ( 0 != postfix)

   921                 {

   922                 itemText.Append( KSpace );

   923                 itemText.AppendNum( postfix );

   924 

   925                 // do number conversion

   926                 AknTextUtils::

   927                     DisplayTextLanguageSpecificNumberConversion( itemText );

   928                 

   929                 iListName.Copy( itemText );

   930                 settingItem->LoadL();

   931 

   932                 aItem->UpdateListBoxTextL();

   933                 }

   934             }

   935         }

   936     else

   937         {

   938         settingItem->LoadL();

   939         }

   940     CleanupStack::PopAndDestroy( originalSearchStr );

   941     }

   942 

   943 // --------------------------------------------------------------------------

   944 // CMSFillRuleEditList::CheckSameNameL

   945 // check the name is same or not

   946 // --------------------------------------------------------------------------

   947 //

   948 TBool CMSFillRuleEditList::CheckSameNameL( const TDesC& aName ) const

   949     {

   950     RPointerArray<CMSFillList>* iFillListArray = 

   951                 iAppUi->FillRuleController()->FillListArray();

   952 

   953     // fill rule name array is not empty

   954     if ( iFillListArray->Count() > 0 )

   955         {

   956         for ( TInt index = 0; index < iFillListArray->Count(); ++index )

   957             {

   958             // Get fill rule name and put it to the listbox

   959             CCmFillRule* rule = (*iFillListArray)[index]->List();

   960             HBufC* listName =

   961                 CnvUtfConverter::ConvertToUnicodeFromUtf8L( rule->Name() );

   962             CleanupStack::PushL( listName );

   963             // whether there is a same name fill rule

   964             if ( aName == *listName )

   965                 {

   966                 CleanupStack::PopAndDestroy( listName );

   967                 return ETrue;

   968                 }

   969             CleanupStack::PopAndDestroy( listName );

   970             }

   971         }

   972     return EFalse;

   973     }

   974 

   975 // --------------------------------------------------------------------------

   976 // CMSFillRuleEditList::SaveAndPreprocesslistL

   977 // Saves modified list and preprocesses it

   978 // --------------------------------------------------------------------------

   979 //

   980 void CMSFillRuleEditList::SaveAndPreprocesslistL( CAknSettingItem* aItem )

   981     {

   982     LOG(_L("[MediaServant]\t CMSFillRuleEditList::\

   983     SaveAndPreprocesslistL"));

   984 

   985     // save rules

   986     iAppUi->FillRuleController()->SaveRulesL();

   987     // we'll lost iRule after update...

   988     iAppUi->FillRuleController()->UpdateArrayL();

   989     // ...so get it again

   990     iRule = (*iAppUi->FillRuleController()->

   991                     FillListArray())[iSelectedList]->List();

   992 

   993     // if multiselectionitem is edited start data reading after preprocess

   994    if ( aItem->Identifier() == EMSGenre ||

   995         aItem->Identifier() == EMSArtist ||

   996         aItem->Identifier() == EMSAlbum ||

   997         aItem->Identifier() == EMSTrack||

   998         aItem->Identifier() == EMSTitleName)

   999         {

  1000         iState = EMSFetchMetadata;

  1001         }

  1002 

  1003     // if other item than name is changed preprocessing is needed

  1004     if ( aItem->Identifier() != EMSListName )

  1005         {

  1006         PreprocessListL();

  1007         }

  1008     }

  1009 

  1010 // --------------------------------------------------------------------------

  1011 // CMSFillRuleEditList::ActivateL

  1012 // Asks setting page selection status from setting item

  1013 // --------------------------------------------------------------------------

  1014 //

  1015 TBool CMSFillRuleEditList::CheckSettingPageAcceptance(

  1016                                             CAknSettingItem* aItem )

  1017     {

  1018     LOG(_L("[MediaServant]\t CMSFillRuleEditList::\

  1019     CheckSettingPageAcceptance"));

  1020 

  1021     TBool status( EFalse );

  1022 

  1023     switch ( aItem->Identifier() )

  1024         {

  1025         case EMSShrinkImages:

  1026         // fall through

  1027         case EMSAmount:

  1028         // fall through

  1029         case EMSStartingWith:

  1030         // fall through

  1031         case EMSMinFileSize:

  1032         // fall through

  1033         case EMSMaxFileSize:

  1034         // fall through

  1035         case EMSTrackLength:

  1036         // fall through

  1037         case EMSFileSize:

  1038             {

  1039             CMSEnumeratedTextPopupSettingItem* item =

  1040                     static_cast<CMSEnumeratedTextPopupSettingItem*>(aItem);

  1041             status = item->SettingAccepted();

  1042             break;

  1043             }

  1044         case EMSListName:

  1045         // fall through

  1046         case EMSServers:

  1047         // fall through

  1048         case EMSFreeText:

  1049         // fall through

  1050         case EMSTitleName:

  1051         // fall through

  1052         case EMSGenre:

  1053         // fall through

  1054         case EMSArtist:

  1055         // fall through

  1056         case EMSAlbum:

  1057         // fall through

  1058         case EMSTrack:

  1059 

  1060             {

  1061             CMSTextSettingItem* item =

  1062                     static_cast<CMSTextSettingItem*>(aItem);

  1063             status = item->SettingAccepted();

  1064             break;

  1065             }

  1066 

  1067         case EMSDateFrom:

  1068         // fall through

  1069         case EMSDateUntil:

  1070             {

  1071             CMSTimeOrDateSettingItem* item =

  1072                     static_cast<CMSTimeOrDateSettingItem*>(aItem);

  1073             status = item->SettingAccepted();

  1074             break;

  1075             }

  1076         default:

  1077             {

  1078             LOG(_L("[MediaServant]\t CMSFillRuleEditList::\

  1079             CheckSettingPageAcceptance no such item"));

  1080             break;

  1081             }

  1082         }

  1083 

  1084     return status;

  1085     }

  1086 // --------------------------------------------------------------------------

  1087 // CMSFillRuleEditList::ActivateL

  1088 // Activates setting list

  1089 // --------------------------------------------------------------------------

  1090 //

  1091 void CMSFillRuleEditList::ActivateL()

  1092     {

  1093     LOG(_L("[MediaServant]\t CMSFillRuleEditList::ActivateL"));

  1094 

  1095     // hide all items by default

  1096     // index starts from '1' because list name is always visible

  1097     // index stops to count-1 because "add more rules" is always visible

  1098     for (TInt index = 1 ;index < SettingItemArray()->Count()-1; index++)

  1099         {

  1100         SettingItemArray()->At( index )->SetHidden(ETrue);

  1101         }

  1102 

  1103     CAknSettingItemArray* itemArray = SettingItemArray();

  1104     // set template rules visible

  1105     for (TInt idx = 0; idx < iVisibleRules.Count(); idx++)

  1106         {

  1107         CAknSettingItem* item = SearchItemById( iVisibleRules[idx] );

  1108         if ( item )

  1109             {

  1110             item->SetHidden( EFalse);

  1111             }

  1112         }

  1113     // Show also additional rules if user has changed the default value

  1114     DisplayModifiedAdditionalRules();

  1115     // visibility of some items may have changed

  1116     HandleChangeInItemArrayOrVisibilityL();

  1117 

  1118     CAknSettingItemList::ActivateL();

  1119     }

  1120 

  1121 // --------------------------------------------------------------------------

  1122 // void CMSFillRuleEditList::ReadTemplateRulesL

  1123 // reads fill rule name

  1124 // --------------------------------------------------------------------------

  1125 //

  1126 void CMSFillRuleEditList::ReadTemplateRulesL( TInt aTemplate )

  1127     {

  1128     LOG(_L("[MediaServant]\t CMSFillRuleEditList::ReadTemplateRulesL"));

  1129 

  1130     TResourceReader rsReader;

  1131 

  1132     switch ( aTemplate )

  1133         {

  1134         case EMSDefaultImageList: