FCL/sf/app/webuis: comparison browserui/browser/BrowserAppSrc/BrowserPreferences.cpp

equal deleted inserted replaced

-:4530440261a8
+:16a119033e3e
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *     It manages WmlBrowser's preferences
 *
 *
 */
 void CBrowserPreferences::ConstructL( TBrowserOverriddenSettings* aSettings )
 {
 LOG_ENTERFN("CBrowserPreferences::ConstructL");
 iObservers = new ( ELeave ) CArrayPtrFlat< MPreferencesObserver >( 1 );
 iCommsModel.ApDb().AddObserverL( this );
 	iApDH = CApDataHandler::NewLC( iCommsModel.CommsDb() );
 	CleanupStack::Pop();
 iVpnEngine = CVpnApEngine::NewLC( &(iCommsModel.CommsDb()) );
 CleanupStack::Pop();
 	CRepository* repository = CRepository::NewL( KCRUidBrowserUiLV );
 if ( repository->Get(
 KBrowserUiCommonFlags, iEngineLocalFeaturesBitmask ) != KErrNone )
 {
 // in case of problems, assume everything is off
 iEngineLocalFeaturesBitmask = 0;
 }
 if ( repository->Get(
 KBrowserUiCommonFlags, iUiLocalFeaturesBitmask ) != KErrNone )
 {
 // in case of problems, assume everything is off
 iUiLocalFeaturesBitmask = 0;
 }
 if ( repository->Get(
 KBrowserUiCdmaFlags, iCdmaUiLocalFeaturesBitmask ) != KErrNone )
 {
 // in case of problems, assume everything is off
 iCdmaUiLocalFeaturesBitmask = 0;
 }
 delete repository;
 iRepository = CRepository::NewL( KCRUidBrowser );
 SetIntValueL( KBrowserConfirmedDTMFOnce, EFalse );
 //Read ini values to local variables.
 TRAP_IGNORE( RestoreSettingsL() );
 // and overwrite some of them if needed
 if ( aSettings )
 {
 SetOverriddenSettingsL( aSettings );
 }
 TBool CBrowserPreferences::EngineLocalFeatureSupported( const TInt aFeature ) const
 {
 LOG_ENTERFN("CBrowserPreferences::EngineLocalFeatureSupported");
 BROWSER_LOG( ( _L( "EnginLocalFeatureSupported returns %d" ),
 (iEngineLocalFeaturesBitmask & aFeature) ) );
 return (iEngineLocalFeaturesBitmask & aFeature);
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::UiLocalFeatureSupported
 // ----------------------------------------------------------------------------
 	{
 LOG_ENTERFN("CBrowserPreferences::NewLC");
 	CBrowserPreferences* result;
 	result = new ( ELeave ) CBrowserPreferences( aCommsModel, aApiProvider );
 	CleanupStack::PushL( result );
 	result->ConstructL( aSettings );
 	return result;
 	}
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::NewL
 	{
 LOG_ENTERFN("CBrowserPreferences::NewL");
 	CBrowserPreferences* result;
 	result = CBrowserPreferences::NewLC( aCommsModel, aApiProvider, aSettings );
 	CleanupStack::Pop();
 	return result;
 	}
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::CBrowserPreferences
 // ----------------------------------------------------------------------------
 //
 CBrowserPreferences::CBrowserPreferences( MCommsModel& aCommsModel,
 MApiProvider& aApiProvider) :
 iApiProvider( aApiProvider ),
 iCommsModel( aCommsModel ),
 iEmbeddedMode( EFalse )
 {
 LOG_ENTERFN("CBrowserPreferences::CBrowserPreferences");
 iAllPreferences.iCookies = EWmlSettingsCookieAllow;
 iAllPreferences.iHttpSecurityWarnings = ETrue;
 iAllPreferences.iDownloadsOpen = ETrue;
 iAllPreferences.iConnDialogs = ETrue;
 iAllPreferences.iHomePgURL = NULL;
 iAllPreferences.iSearchPgURL = NULL;
 iAllPreferences.iQueryOnExit = EFalse;
 iAllPreferences.iSendReferrer = EFalse;
 	delete iAllPreferences.iDefaultAPDetails;
 delete iRepository;
 // For short cut functions
 delete iAllPreferences.iShortCutFuncHomePg;
 iAllPreferences.iShortCutFuncHomePg = NULL;
 delete iAllPreferences.iShortCutFuncBkMark;
 iAllPreferences.iShortCutFuncBkMark = NULL;
 delete iAllPreferences.iShortCutFuncFindKeyWord;
 iAllPreferences.iShortCutFuncFindKeyWord = NULL;
 delete iAllPreferences.iShortCutFuncPrePage;
 iAllPreferences.iShortCutFuncPrePage = NULL;
 delete iAllPreferences.iShortCutFuncSwitchWin;
 iAllPreferences.iShortCutFuncSwitchWin = NULL;
 delete iAllPreferences.iShortCutFuncMiniImage;
 iAllPreferences.iShortCutFuncMiniImage = NULL;
 delete iAllPreferences.iShortCutFuncFullScreen;
 iAllPreferences.iShortCutFuncFullScreen = NULL;
 delete iAllPreferences.iShortCutFuncGoAddr;
 iAllPreferences.iShortCutFuncGoAddr = NULL;
 delete iAllPreferences.iShortCutFuncZoomIn;
 iAllPreferences.iShortCutFuncZoomIn = NULL;
 delete iAllPreferences.iShortCutFuncZoomOut;
 iAllPreferences.iShortCutFuncZoomOut = NULL;
 delete iAllPreferences.iShortCutFuncZoomMode;
 iAllPreferences.iShortCutFuncZoomMode = NULL;
 delete iAllPreferences.iUrlSuffixList;
 iAllPreferences.iUrlSuffixList = NULL;
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::AddObserverL
 // ----------------------------------------------------------------------------
 for ( i = 0; i < count; i++ )
 {
 if ( iObservers->At( i ) == anObserver )
 {
 iObservers->Delete( i );
 break;
 }
 }
 }
 // ----------------------------------------------------------------------------
 TBrCtlDefs::TBrCtlSettings aSettingType = TBrCtlDefs::ESettingsUnknown )
 {
 LOG_ENTERFN("CBrowserPreferences::NotifyObserversL");
 TInt i;
 TInt count = iObservers->Count();
 // Passed struct of all preferences to observers
 for ( i = 0; i < count; i++ )
 {
 iObservers->At( i )->HandlePreferencesChangeL(
 aEvent,
 iAllPreferences,
 aSettingType );
 }
 }
 {
 LOG_ENTERFN("CBrowserPreferences::RestoreSettingsL");
 //
 //  READ USER VARIATED SETTINGS
 //
 	//Read auto load content setting
 iAllPreferences.iAutoLoadContent = GetIntValue( KBrowserNGImagesEnabled );
 //Read font size
 iAllPreferences.iFontSize = GetIntValue( KBrowserNGFontSize );
 	// Read Allow Cookies setting
 if ( GetIntValue( KBrowserNGCookiesEnabled ) )
 {
 iAllPreferences.iCookies = EWmlSettingsCookieAllow;
 }
 else
 {
 iAllPreferences.iCookies = EWmlSettingsCookieReject;
 }
 // Read ECMA Setting
 if ( GetIntValue( KBrowserNGECMAScriptSupport ) )
 {
 iAllPreferences.iEcma = EWmlSettingsECMAEnable;
 }
 else
 {
 iAllPreferences.iIMEINotification = EWmlSettingsIMEIDisable;
 }
 }
 TInt encoding;
 	iRepository->Get( KBrowserNGEncoding, encoding );
 iAllPreferences.iEncoding = ( TUint32 ) encoding;
 iAllPreferences.iScriptLog = GetIntValue( KBrowserNGScriptLog ) ;
 //Read Fullscreen setting
 TInt value;
 value = GetIntValue ( KBrowserNGFullScreen );
 case KBrowserFullScreenSettingDataSoftkeysOff:
 	{
 iAllPreferences.iFullScreen = EWmlSettingsFullScreenFullScreen;
 break;
 	}
 case KBrowserFullScreenSettingDataSoftkeysOn:
 {
 iAllPreferences.iFullScreen = EWmlSettingsFullScreenSoftkeysOnly;
 break;
 }
 default:
 {
 break;
 }
 }
 switch(adBm)
 {
 case (KBrowserAdaptiveBookmarksSettingDataOn):
 {
 iAllPreferences.iAdaptiveBookmarks =
 EWmlSettingsAdaptiveBookmarksOn;
 break;
 }
 case (KBrowserAdaptiveBookmarksSettingDataHideFolder):
 {
 iAllPreferences.iAdaptiveBookmarks =
 EWmlSettingsAdaptiveBookmarksHideFolder;
 break;
 }
 case (KBrowserAdaptiveBookmarksSettingDataOff):
 {
 iAllPreferences.iAdaptiveBookmarks =
 EWmlSettingsAdaptiveBookmarksOff;
 break;
 }
 default:
 {
 break;
 }
 }
 }
 //
 //  READ OPERATOR VARIATED SETTINGS
 //
 	iAllPreferences.iHomePgType =
 ( TWmlSettingsHomePage ) GetIntValue( KBrowserNGHomepageType );
 iAllPreferences.iPageOverview = GetIntValue (
 		                                    KBrowserNGPageOverview );
 	iAllPreferences.iBackList = GetIntValue (
 		                                    KBrowserNGBackList );
 	iAllPreferences.iAutoRefresh = GetIntValue (
 		                                    KBrowserNGAutoRefresh );
 if(PROGRESSIVE_DOWNLOAD)
 	    {
 	iAllPreferences.iDownloadsOpen = GetIntValue ( KBrowserNGOpenDownloads );
 	}
 else
 	{
 	iAllPreferences.iDownloadsOpen = EFalse;
 	}
 //Read suppress security UI setting
 iAllPreferences.iHTTPSecuritySupressed = GetIntValue ( KBrowserSecurityUI );
 //Read show connection queries setting
 iAllPreferences.iConnDialogs = GetIntValue( KBrowserConnectionDialogs );
 if( !iAllPreferences.iHTTPSecuritySupressed )
 {
 // Read HTTP security warnings setting
 	    iAllPreferences.iHttpSecurityWarnings = GetIntValue (
 		                            KBrowserNGShowSecurityWarnings );
 }
 else
 {
 //we don't want to see sec warning because they're supressed
 iAllPreferences.iHttpSecurityWarnings = EFalse;
 }
 // Media Volume uses different SD ini. Revert to Browser SD ini after use
 iAllPreferences.iMediaVolume = GetIntValue( KBrowserMediaVolumeControl );
 // Pop up Blocking
 iAllPreferences.iPopupBlocking = GetIntValue( KBrowserNGPopupBlocking );
 // Form Data Saving
 iAllPreferences.iFormDataSaving = (TWmlSettingsFormData) GetIntValue( KBrowserFormDataSaving );
 // Access Keys
 iAllPreferences.iAccessKeys = (TBool) GetIntValue( KBrowserNGAccessKeys );
 // The leaving functions come at the end
 // Search Page
 if ( iAllPreferences.iSearchPgURL )
 {
 delete iAllPreferences.iSearchPgURL;
 iAllPreferences.iSearchPgURL = NULL;
 }
 // Web reed feeds settings - begin
 iAllPreferences.iAutomaticUpdatingAP = GetIntValue( KBrowserNGAutomaticUpdatingAccessPoint );
 iAllPreferences.iAutomaticUpdatingWhileRoaming = GetIntValue( KBrowserNGAutomaticUpdatingWhileRoaming );
 // Web reed feeds settings - end
 if (CBrowserAppUi::Static()->OrientationCanBeChanged() )
 {
 iAllPreferences.iRotateDisplay = GetIntValue( KBrowserNGRotateDisplay );
 }
 // Read Accesss point selection mode for advanced settings
 const TInt selectionMode = GetIntValue( KBrowserAccessPointSelectionMode );
 switch ( selectionMode )
 {
 case EBrowserCenRepApSelModeUserDefined:
 {
 iAllPreferences.iAccessPointSelectionMode = EConnectionMethod;
 break;
 }
 case EBrowserCenRepApSelModeAlwaysAsk:
 {
 iAllPreferences.iAccessPointSelectionMode = EAlwaysAsk;
 break;
 }
 case EBrowserCenRepApSelModeDestination:
 {
 iAllPreferences.iAccessPointSelectionMode = EDestination;
 break;
 }
 default: // Default to Always ask.
 {
 iAllPreferences.iAccessPointSelectionMode = EAlwaysAsk;
 break;
 }
 }
 //we differentiate by connecting with a Snap or an access point
 if (iAllPreferences.iAccessPointSelectionMode == EConnectionMethod)
 	    {
 //Read default AP setting
 ap = GetIntValue( KBrowserDefaultAccessPoint );
 SetDefaultAccessPointL( ap );
 		}
 else if (iAllPreferences.iAccessPointSelectionMode == EDestination)
 		{
 		iAllPreferences.iDefaultSnapId = GetIntValue( KBrowserNGDefaultSnapId );
 		}
 // For Short Cut keys
 if ( iAllPreferences.iShortCutFuncHomePg )
 {
 delete iAllPreferences.iShortCutFuncHomePg;
 iAllPreferences.iShortCutFuncHomePg = NULL;
 TPtr func10 = iAllPreferences.iShortCutFuncFullScreen->Des();
 GetStringValueL( KBrowserNGShortCutFuncFullScreen, KShortCutFuncStringLength, func10 );
 // For Configuring Toolbar Buttons
 iAllPreferences.iToolbarOnOff       = GetIntValue( KToolbarOnOff );
 iAllPreferences.iToolbarButton1Cmd  = GetIntValue( KToolbarButton1Cmd );
 iAllPreferences.iToolbarButton2Cmd  = GetIntValue( KToolbarButton2Cmd );
 iAllPreferences.iToolbarButton3Cmd  = GetIntValue( KToolbarButton3Cmd );
 iAllPreferences.iToolbarButton4Cmd  = GetIntValue( KToolbarButton4Cmd );
 iAllPreferences.iToolbarButton5Cmd  = GetIntValue( KToolbarButton5Cmd );
 iAllPreferences.iToolbarButton6Cmd  = GetIntValue( KToolbarButton6Cmd );
 iAllPreferences.iToolbarButton7Cmd  = GetIntValue( KToolbarButton7Cmd );
 // For configuring Shortcut Keys
 iAllPreferences.iShortcutKeysForQwerty  = GetIntValue( KShortcutKeysForQwerty );
 iAllPreferences.iShortcutKey1Cmd  = GetIntValue( KShortcutKey1Cmd );
 iAllPreferences.iShortcutKey2Cmd  = GetIntValue( KShortcutKey2Cmd );
 iAllPreferences.iShortcutKey3Cmd  = GetIntValue( KShortcutKey3Cmd );
 iAllPreferences.iShortcutKey4Cmd  = GetIntValue( KShortcutKey4Cmd );
 iAllPreferences.iShortcutKey5Cmd  = GetIntValue( KShortcutKey5Cmd );
 iAllPreferences.iZoomLevelMin = GetIntValue( KBrowserNGZoomMin );
 iAllPreferences.iZoomLevelMax = GetIntValue( KBrowserNGZoomMax );
 iAllPreferences.iZoomLevelDefault = GetIntValue( KBrowserNGZoomDefault );
 iAllPreferences.iMaxRecentUrlsToShow = GetIntValue( KBrowserNGMaxRecentUrls );
 iAllPreferences.iSearch = GetIntValue( KBrowserSearch );
 iAllPreferences.iService = GetIntValue( KBrowserServices );
-}
+iAllPreferences.iCursorShowMode = (TBrCtlDefs::TCursorSettings)GetIntValue( KBrowserCursorShowMode );
+	}
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::AllPreferencesL
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 TBool CBrowserPreferences::VpnDataL( TUint aDefaultAccessPoint, CVpnApItem& aVpnItem )
 {
 TBool ret( EFalse );
 if( iVpnEngine->IsVpnApL( aDefaultAccessPoint ) )
 {
 iVpnEngine->VpnDataL( aDefaultAccessPoint, aVpnItem );
 ret = ETrue;
 }
 return ret;
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetDefaultAccessPointL
 // if user-defined destination then check that destination still exists.
 // if it doesn't, reset access point to always ask and homepage to blank access point home page.
 TUint snapId = iAllPreferences.iDefaultSnapId;
 if (snapId != KWmlNoDefaultSnapId)
 {
 			TRAPD(err, RCmDestination dest = cmManager.DestinationL( snapId ));
 			if (err != KErrNone)
 			    {
 			    aDefaultAccessPoint = KWmlNoDefaultAccessPoint;
 	    	aAssocVpn = KWmlNoDefaultAccessPoint;
 			SetAccessPointSelectionModeL(EAlwaysAsk );
 			if (iAllPreferences.iHomePgType == EWmlSettingsHomePageAccessPoint)
 				{
 				HBufC* buf = HBufC::NewLC( KMaxHomePgUrlLength );  // cleanupstack
 			TPtr ptr( buf->Des() );
 }
 		    cmManager.Close();
 			break;
 	}
 //if connecting with Iap Id
 case EConnectionMethod:
 {
 // if user-defined access point then check that access point still exists.
 // if it doesn't, reset access point to always ask and homepage to blank access point home page.
 	        CApListItem* apItem = iCommsModel.AccessPointsL()->ItemForUid( aDefaultAccessPoint );
 	        if (apItem == NULL)
 {
 TBool isVpn = EFalse;
 TRAPD(leaveCode, isVpn = iVpnEngine->IsVpnApL( aDefaultAccessPoint ))
 if ( leaveCode == KErrNone )
 {
 if ( isVpn )
 {
 BROWSER_LOG( ( _L( " This is VPN AP which has a snap in it" ) ) );
 break;
 }
 }
 	    	aDefaultAccessPoint = KWmlNoDefaultAccessPoint;
 	    	aAssocVpn = KWmlNoDefaultAccessPoint;
 	    	delete iAllPreferences.iDefaultAPDetails;
 			iAllPreferences.iDefaultAPDetails = NULL;
 HomePageUrlL( ptr, ETrue );
 SetHomePageUrlL(ptr);
 			CleanupStack::PopAndDestroy( buf );
 				}
 		    	}
 		    break;
 	}
 default:
 	{
 	break;
 	}
 }
 	// check web feeds for deleted access point
 	CApListItem* apItem = iCommsModel.AccessPointsL()->ItemForUid( iAllPreferences.iAutomaticUpdatingAP );
 	if (apItem == NULL)
 		{
 SetAutomaticUpdatingApL( KWmlNoDefaultAccessPoint );
 iVpnEngine->VpnDataL( aDefaultAccessPoint, *iVpnItem );
 TUint32 ass( aDefaultAccessPoint );
 iVpnItem->ReadUint( EApVpnWapAccessPointID, ass );
 aAssocVpn = ass;
 // get real WAP id
 TUint32 ap( aDefaultAccessPoint );
 iVpnItem->ReadUint( EApVpnRealWapID, ap );
 aDefaultAccessPoint = ap;
 }
 BROWSER_LOG( ( _L( "VPN OK" ) ) );
 	iAllPreferences.iDefaultAccessPoint = aDefaultAccessPoint;
 	iAllPreferences.iAssocVpn = aAssocVpn;
 	CApAccessPointItem* api = CApAccessPointItem::NewLC();//maybe we can optimise this too
 	BROWSER_LOG( ( _L( "CApAccessPointItem OK" ) ) );
 TInt err;
 if  ( iOverridenSettings )
 {
 iCustomAp = iOverridenSettings->GetBrowserSetting(
 EBrowserOverSettingsCustomAp );
 }
 if ( ( iOverridenSettings ) &&  iCustomAp  )
 {
 	    TRAP( err, iApDH->AccessPointDataL( iCustomAp, *api ) );
 	        TRAP( err, iApDH->AccessPointDataL( iAllPreferences.iDefaultAccessPoint, *api ) );
 }
 }
 else
 {
 	    TRAP( err, iApDH->AccessPointDataL(
 	                            iAllPreferences.iDefaultAccessPoint, *api ) );
 }
 BROWSER_LOG( ( _L( " AccessPointDataL: %d" ), err ) );
 	//Reset default AP pointer and delete the data
 	delete iAllPreferences.iDefaultAPDetails;
 	iAllPreferences.iDefaultAPDetails = NULL;
 	if  ( err != KErrNone )//Let's select the first
 		{
 #ifndef __WINSCW__ //we will not select on Wins (defaultap will be assigned a uid indicating that there is
 					//no default ap) but rather let ConnMan show the Conn Dlg
 		// The first valid access point has to be selected if exists
 		LOG_WRITE("WE SHOULD NOT BE HERE!!!");
 		CApSelect* apSelect = CApSelect::NewLC
 			(
 			iCommsModel.CommsDb(),
 			KEApIspTypeAll, //KEApIspTypeWAPMandatory,
 			EApBearerTypeAll,
 			KEApSortNameAscending,
 			EIPv4 | EIPv6
 			);
 		if ( apSelect->MoveToFirst() )
 		CleanupStack::PopAndDestroy(); // apSelect
 		CleanupStack::Pop();//api
 #else
 		iAllPreferences.iDefaultAccessPoint = KWmlNoDefaultAccessPoint;
 		iAllPreferences.iDefaultAPDetails = NULL;
 		CleanupStack::PopAndDestroy( api );
 #endif//WINSCW
 		}
 	else
 		{
 		iAllPreferences.iDefaultAPDetails = api;//store new default accesspoint details
 		CleanupStack::Pop( ); // api
 		}
 	/*
 	* If VPN set VPN AP ID to default access point!
 	*/
 	if( KWmlNoDefaultAccessPoint != iAllPreferences.iAssocVpn )
 	    {
 	    iAllPreferences.iDefaultAccessPoint = iAllPreferences.iAssocVpn;
 	    }
 if( !iEmbeddedMode )
 {
 	    //Store ini value / gateway
 SetIntValueL ( KBrowserDefaultAccessPoint,
 iAllPreferences.iDefaultAccessPoint );
 }
 NotifyObserversL( EPreferencesItemChange );
 	//  LOG_LEAVEFN("CBrowserPreferences::SetDefaultAccessPointL");
 	}
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetDefaultSnapId: DestNetChange
 // ----------------------------------------------------------------------------
 //
 void CBrowserPreferences::SetDefaultSnapId (TUint aSnapId)
 		{
 		//storing the value of the default snap ID
 		iAllPreferences.iDefaultSnapId = aSnapId;
 SetIntValueL ( KBrowserNGDefaultSnapId,
 iAllPreferences.iDefaultSnapId );
 		}
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetAutoLoadContentL
 iAllPreferences.iAutoLoadContent = aAutoLoadContent;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserNGImagesEnabled,
 iAllPreferences.iAutoLoadContent );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsAutoLoadImages );
 }
 }
 // ----------------------------------------------------------------------------
 iAllPreferences.iPageOverview = aPageOverview;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserNGPageOverview,
 iAllPreferences.iPageOverview );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsPageOverview);
 }
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetBackListL
 // ----------------------------------------------------------------------------
 //
 void CBrowserPreferences::SetBackListL( TBool aBackList )
 iAllPreferences.iBackList = aBackList;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserNGBackList,
 iAllPreferences.iBackList );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsBackList);
 }
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetAutoRefreshL
 // ----------------------------------------------------------------------------
 //
 void CBrowserPreferences::SetAutoRefreshL( TBool aAutoRefresh )
 iAllPreferences.iAutoRefresh = aAutoRefresh;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserNGAutoRefresh,
 iAllPreferences.iAutoRefresh );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsAutoRefresh);
 }
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetTextWrapL
 // ----------------------------------------------------------------------------
 //
 // Store value in Shared Data and forward new setting to BrCtl
 if ( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserTextWrapEnabled, iAllPreferences.iTextWrap );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsTextWrapEnabled );
 }
 }
 // ----------------------------------------------------------------------------
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserNGFontSize, iAllPreferences.iFontSize );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsFontSize );
 }
 }
 // ----------------------------------------------------------------------------
 {
 LOG_ENTERFN("CBrowserPreferences::SetEncodingL");
 if ( aEncoding != iAllPreferences.iEncoding )
 {
 iAllPreferences.iEncoding = aEncoding;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL ( KBrowserNGEncoding,
 ( TInt ) iAllPreferences.iEncoding );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsCharacterset );
 }
 }
 // ----------------------------------------------------------------------------
 {
 LOG_ENTERFN("CBrowserPreferences::SetScriptLogL");
 if ( aScriptLog != iAllPreferences.iScriptLog )
 {
 iAllPreferences.iScriptLog = aScriptLog;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 TBool ret = SetIntValueL ( KBrowserNGScriptLog,
 ( TInt ) iAllPreferences.iScriptLog );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsScriptLog );
 }
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetAdaptiveBookmarksL
 // ----------------------------------------------------------------------------
 //
 void CBrowserPreferences::SetAdaptiveBookmarksL(
 TWmlSettingsAdaptiveBookmarks aAdaptiveBookmarks )
 {
 LOG_ENTERFN( "CBrowserPreferences::SetAdaptiveBookmarksL" );
 if ( ADAPTIVEBOOKMARKS )
 {
 if ( aAdaptiveBookmarks != iAllPreferences.iAdaptiveBookmarks )
 {
 iAllPreferences.iAdaptiveBookmarks = aAdaptiveBookmarks;
 if( !iEmbeddedMode )
 {
 switch( iAllPreferences.iAdaptiveBookmarks )
 {
 				case (EWmlSettingsAdaptiveBookmarksOn):
 {
 				SetIntValueL ( KBrowserNGAdaptiveBookmarks,
 					KBrowserAdaptiveBookmarksSettingDataOn );
 break;
 }
 case (EWmlSettingsAdaptiveBookmarksHideFolder):
 {
 SetIntValueL ( KBrowserNGAdaptiveBookmarks,
 	KBrowserAdaptiveBookmarksSettingDataHideFolder );
 break;
 }
 case (EWmlSettingsAdaptiveBookmarksOff):
 {
 SetIntValueL ( KBrowserNGAdaptiveBookmarks,
 	KBrowserAdaptiveBookmarksSettingDataOff );
 break;
 }
 default:
 {
 // ---------------------------------------------------------
 //
 void CBrowserPreferences::SetFullScreenL( TWmlSettingsFullScreen aFullScreen )
 {
 LOG_ENTERFN("CBrowserPreferences::SetFullScreenL");
 if ( aFullScreen != iAllPreferences.iFullScreen )
 {
 iAllPreferences.iFullScreen = aFullScreen;
 if( !iEmbeddedMode )
 {
 switch ( iAllPreferences.iFullScreen )
 {
 				case EWmlSettingsFullScreenSoftkeysOnly:
 {
 SetIntValueL ( KBrowserNGFullScreen,
 	KBrowserFullScreenSettingDataSoftkeysOn );
 break;
 }
 case EWmlSettingsFullScreenFullScreen:
 {
 SetIntValueL ( KBrowserNGFullScreen,
 	KBrowserFullScreenSettingDataSoftkeysOff );
 break;
 }
 default:
 {
 break;
 }
 }
 }
 NotifyObserversL( EPreferencesItemChange ); // ContentView is interested
 }
 }
 iAllPreferences.iCookies = aCookies;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserNGCookiesEnabled,
 iAllPreferences.iCookies );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsCookiesEnabled );
 }
 }
 // ----------------------------------------------------------------------------
 iAllPreferences.iEcma = aEcma;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 			SetIntValueL( KBrowserNGECMAScriptSupport,
 			                                    iAllPreferences.iEcma );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsECMAScriptEnabled );
 }
 }
 // ----------------------------------------------------------------------------
 if ( aOpen != iAllPreferences.iDownloadsOpen )
 {
 iAllPreferences.iDownloadsOpen = aOpen;
 if( !iEmbeddedMode )
 {
 			SetIntValueL ( KBrowserNGOpenDownloads,
 				        (TInt) iAllPreferences.iDownloadsOpen );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsAutoOpenDownloads );
 }
 }
 if ( aWarningsOn != iAllPreferences.iHttpSecurityWarnings )
 {
 iAllPreferences.iHttpSecurityWarnings = aWarningsOn;
 if( !iEmbeddedMode )
 {
 			SetIntValueL ( KBrowserNGShowSecurityWarnings,
 				        (TInt) iAllPreferences.iHttpSecurityWarnings );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsSecurityWarnings );
 }
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetIMEINotification
 // ----------------------------------------------------------------------------
 //
 void CBrowserPreferences::SetIMEINotificationL(
 TWmlSettingsIMEI aIMEINotification )
 {
 LOG_ENTERFN("CBrowserPreferences::SetIMEINotificationL");
 if ( IMEI_NOTIFICATION )
 {
 if ( aIMEINotification != iAllPreferences.iIMEINotification )
 {
 iAllPreferences.iIMEINotification = aIMEINotification;
 // Store value in Shared Data and forward new setting to BrCtl
 if( !iEmbeddedMode )
 {
 SetIntValueL( KBrowserIMEINotification,
 iAllPreferences.iIMEINotification );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsIMEINotifyEnabled );
 }
 }
 }
 {
 LOG_ENTERFN("CBrowserPreferences::HandleApDbEventL");
 if ( anEvent == EDbChanged )//maybe somebody has modified the AP (not very likely though)
 {
 SetDefaultAccessPointL( iAllPreferences.iDefaultAccessPoint );
 }
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::HomePageUrlL
 // Get the user defined home page URL from shared data file.
 			// if we are requiring a force load from the shared data, or our homepage
 		    // is set to be something other than the access point's home page, get
 		    // the value of the home page from the shared data
 			homePgFound = GetStringValueL( KBrowserNGHomepageURL, KMaxHomePgUrlLength, aUrl );
 			}
 		else if ((iAllPreferences.iAccessPointSelectionMode == EConnectionMethod) &&
 				 (pgtype == EWmlSettingsHomePageAccessPoint))
 {
 			// The user has a defined access point, and wants to use the access point's
 		// home page
 BROWSER_LOG( ( _L( "HomePageUrl, Access Point" ) ) );
 TUint defaultAp = DefaultAccessPoint();
 if ( defaultAp != KWmlNoDefaultAccessPoint ) // There is an access point defined
 {
 CApAccessPointItem* apItem = iAllPreferences.iDefaultAPDetails;
 if ( apItem )
 // Get the user defined search page URL from shared data file.
 // ----------------------------------------------------------------------------
 //
 TPtrC CBrowserPreferences::SearchPageUrlL()
 {
 LOG_ENTERFN("CBrowserPreferences::SearchPageUrlL");
 TBool urlTooBig = EFalse;
 TInt error = KErrTooBig;
 TInt length = 512;
 do
 iAllPreferences.iSearchPgURL = NULL;
 iAllPreferences.iSearchPgURL = KNullDesC().AllocL();
 }
 NotifyObserversL( EPreferencesItemChange );
 #ifdef _DEBUG
 TPtrC logString = *iAllPreferences.iSearchPgURL;
 BROWSER_LOG( ( _L( "CBrowserPreferences::SearchPageUrlL returns %S" ), &logString ) );
 #endif // _DEBUG
 return iAllPreferences.iSearchPgURL->Des();
 {
 iAllPreferences.iFormDataSaving = aFormDataSaving;
 // TO DO: Add to cenrep
 SetIntValueL( KBrowserFormDataSaving,
 iAllPreferences.iFormDataSaving );
 }
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsAutoFormFillEnabled );
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::GetIntValue
 // ----------------------------------------------------------------------------
 //
 TInt CBrowserPreferences::GetIntValue( TUint32 aKey) const
 {
 LOG_ENTERFN("CBrowserPreferences::GetIntValue");
 TInt retVal = 0;
 	if ( iRepository )
 	   	{
 	iRepository->Get(aKey, retVal);
 	}
 BROWSER_LOG( ( _L( "CBrowserPreferences::GetIntValue returns %d" ), retVal ) );
 return retVal;
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetIntValueL
 // ----------------------------------------------------------------------------
 //
 TBool CBrowserPreferences::SetIntValueL ( TUint32 aKey, const TInt& aValue )
 {
 LOG_ENTERFN("CBrowserPreferences::SetIntValueL");
 BROWSER_LOG( ( _L( "aValue: %d" ), aValue ) );
 // Log setting value BEFORE the change
 #ifdef I__BROWSER_LOG_ENABLED
 TInt preValue;
 	iRepository->Get( aKey, preValue );
 BROWSER_LOG( ( _L( "Prechange CenRep setting value: %d" ), preValue ) );
 #endif // I__BROWSER_LOG_ENABLED
 TBool retVal=EFalse;
 	if ( iRepository && ( KErrNone == iRepository->Set( aKey, aValue ) ) )
 	{
 	retVal = ETrue;
 	}
 // Log setting value AFTER the change
 #ifdef I__BROWSER_LOG_ENABLED
 TInt postValue;
 	iRepository->Get( aKey, postValue );
 BROWSER_LOG( ( _L( "Postchange CenRep setting value: %d" ), postValue ) );
 #endif // I__BROWSER_LOG_ENABLED
 BROWSER_LOG( ( _L( "CBrowserPreferences::SetIntValueL returns %d" ), retVal ) );
 return retVal;
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::GetStringValueL
 // ----------------------------------------------------------------------------
 //
 LOG_ENTERFN("CBrowserPreferences::GetStringValueL(TUint32)");
 HBufC* retVal = NULL;
 TFileName value;
 TInt err( KErrNotFound );
 	if( iRepository )
 		{
 		err = iRepository->Get( aKey, value );
 		}
 	{
 	retVal = HBufC::NewL( value.Length() );
 	TPtr ptr = retVal->Des();
 	ptr.Copy ( value );
 	}
 #ifdef _DEBUG
 TPtrC logString = *retVal;
 BROWSER_LOG( ( _L( "CBrowserPreferences::GetStringValueL returns %S" ), &logString ) );
 #endif // _DEBUG
 return retVal;
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::GetStringValueL
 // ----------------------------------------------------------------------------
 //
 TInt CBrowserPreferences::GetStringValueL(
 		TUint32 aKey, TInt aMaxBufSize,
 		TDes& aBuf) const
 {
 LOG_ENTERFN("CBrowserPreferences::GetStringValueL(TUint32,TInt,TDes&)");
 // Not sure this works, but CRepository has no information about the return
 // values of the methods.
 // So dont know if iRepository->Get returns with an errorid on error,therefore
 // error = iRepository->Get( aKey, ptr ) may not work.
 TInt length( 256 );
 HBufC* value = HBufC::NewL( length );
 TPtr ptr = value->Des();
 TInt error;
 	error = iRepository->Get( aKey, ptr );
 for( length=length*2; (error==KErrTooBig) && (length<aMaxBufSize); length=length*2)
 {
 delete value;
 value = HBufC::NewL( length );
 ptr = value->Des();
 		error = iRepository->Get( aKey, ptr );
 }
 if( error == KErrNone )
 {
 aBuf.Zero();
 aBuf.Append( ptr );
 }
 delete value;
 BROWSER_LOG( ( _L( "CBrowserPreferences::GetStringValueL(TUint32,TInt,TDes&) returns %d" ),
 error ) );
 return error;
 }
 #ifdef _DEBUG
 TPtrC paramVal = aValue;
 BROWSER_LOG( ( _L( "aValue %S" ), &paramVal ) );
 HBufC* doNothing = HBufC::NewL( 512 );
 TPtr preChange = doNothing->Des();
 	iRepository->Get( aKey, preChange );
 BROWSER_LOG( ( _L( "Prechange CenRep setting value: %S" ), &preChange ) );
 delete doNothing;
 #endif // _DEBUG
 TBool retVal=EFalse;
 	if ( iRepository && ( KErrNone == iRepository->Set( aKey, aValue ) ) )
 	{
 	retVal = ETrue;
 	}
 // Log setting value AFTER the change
 #ifdef _DEBUG
 HBufC* doNothing2 = HBufC::NewL( 512 );
 TPtr postChange = doNothing2->Des();
 		iRepository->Get( aKey, postChange );
 BROWSER_LOG( ( _L( "Postchange CenRep setting value: %S" ), &postChange ) );
 delete doNothing2;
 #endif // _DEBUG
 BROWSER_LOG( ( _L( "CBrowserPreferences::SetStringValueL returns %d" ), retVal) );
 return retVal;
 }
 // ----------------------------------------------------------------------------
 if( aSettings != NULL )
 {
 TUint tempValue;
 iOverriden = ETrue;
 iOverridenSettings = aSettings;
 // Check overridden settings by looking at their default values
 // (see how Launcher2 sets them in the OverriddenSettings constructor)
 tempValue = iOverridenSettings->GetBrowserSetting( EBrowserOverSettingsCustomAp );
 if( tempValue != 0 )
 {
 iCustomAp = tempValue;
 	SetDefaultAccessPointL( iCustomAp );
 }
 tempValue = iOverridenSettings->GetBrowserSetting( EBrowserOverSettingsAutoLoadImages );
 if( tempValue != KMaxTUint )
 {
 iAllPreferences.iAutoLoadContent = tempValue;
 }
 tempValue = iOverridenSettings->GetBrowserSetting( EBrowserOverSettingsFontSize );
 if( tempValue != EBrowserOverFontSizeLevelUndefined )
 LOG_ENTERFN("CBrowserPreferences::SetEmbeddedModeL");
 iEmbeddedMode = aEmbeddedMode;
 if( iEmbeddedMode /* && ApiProvider().StartedUp()*/ )
 {
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsEmbedded );
 }
 return;
 }
 LOG_ENTERFN("CBrowserPreferences::SetHomePageUrlL");
 if( aHomePageURL.Length() )
 {
 // Save the homepage with a scheme (default is http if not specified).
 HBufC* temp = Util::AllocateUrlWithSchemeL( aHomePageURL );
 delete iAllPreferences.iHomePgURL;
 iAllPreferences.iHomePgURL = temp;
 SetStringValueL( KBrowserNGHomepageURL,
 iAllPreferences.iHomePgURL->Des() );
 }
 }
 // ----------------------------------------------------------------------------
 void CBrowserPreferences::SetSearchPageUrlL( const TDesC& aSearchPageURL )
 {
 LOG_ENTERFN("CBrowserPreferences::SetSearchPageUrlL");
 // Save the searchpage with a scheme (default is http if not specified).
 HBufC* temp = Util::AllocateUrlWithSchemeL( aSearchPageURL );
 delete iAllPreferences.iSearchPgURL;
 iAllPreferences.iSearchPgURL = temp;
 SetStringValueL( KBrowserNGSearchPageURL,
 	                            iAllPreferences.iSearchPgURL->Des() );
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::FlushSD()
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetAccessPointSelectionModeL
 // ----------------------------------------------------------------------------
 //
 void CBrowserPreferences::SetAccessPointSelectionModeL(
 TCmSettingSelectionMode aAccessPointSelectionMode )
 {
 LOG_ENTERFN("CBrowserPreferences::SetAccessPointSelectionModeL");
 	if ( aAccessPointSelectionMode != iAllPreferences.iAccessPointSelectionMode )
 		{
 		iAllPreferences.iAccessPointSelectionMode = aAccessPointSelectionMode;
 switch ( aAccessPointSelectionMode )
 {
 case EAlwaysAsk:
 {
 SetIntValueL ( KBrowserAccessPointSelectionMode, EBrowserCenRepApSelModeAlwaysAsk );
 break;
 }
 case EDestination:
 {
 SetIntValueL ( KBrowserAccessPointSelectionMode, EBrowserCenRepApSelModeDestination );
 break;
 }
 case EConnectionMethod:
 {
 SetIntValueL ( KBrowserAccessPointSelectionMode, EBrowserCenRepApSelModeUserDefined );
 break;
 }
 default:
 {
 SetIntValueL ( KBrowserAccessPointSelectionMode, EBrowserCenRepApSelModeAlwaysAsk );
 break;
 }
 }
 		}
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetAutomaticUpdatingApL
 // ----------------------------------------------------------------------------
 {
 LOG_ENTERFN("CBrowserPreferences::SetAutomaticUpdatingWhileRoamingL");
 if ( aAutoUpdateRoaming != iAllPreferences.iAutomaticUpdatingWhileRoaming )
 {
 iAllPreferences.iAutomaticUpdatingWhileRoaming = aAutoUpdateRoaming;
 SetIntValueL( KBrowserNGAutomaticUpdatingWhileRoaming,
 iAllPreferences.iAutomaticUpdatingWhileRoaming );
 	}
 }
 // ---------------------------------------------------------
 // CBrowserPreferences::SetToolbarOnOffL()
 // ---------------------------------------------------------
 //
 void CBrowserPreferences::SetToolbarOnOffL(TInt aCommand)
 {
 if ( aCommand != iAllPreferences.iToolbarOnOff )
 {
 iAllPreferences.iToolbarOnOff = aCommand;
 SetIntValueL( KToolbarOnOff, iAllPreferences.iToolbarOnOff );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarOnOff );
 }
 }
 // ---------------------------------------------------------
 // CBrowserPreferences::SetToolbarButton1CmdL()
 // ---------------------------------------------------------
 //
 void CBrowserPreferences::SetToolbarButton1CmdL(TInt aCommand)
 {
 if ( aCommand != iAllPreferences.iToolbarButton1Cmd )
 {
 iAllPreferences.iToolbarButton1Cmd = aCommand;
 SetIntValueL( KToolbarButton1Cmd, iAllPreferences.iToolbarButton1Cmd );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarButton1Cmd );
 }
 }
 {
 if ( aCommand != iAllPreferences.iToolbarButton2Cmd )
 {
 iAllPreferences.iToolbarButton2Cmd = aCommand;
 SetIntValueL( KToolbarButton2Cmd, iAllPreferences.iToolbarButton2Cmd );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarButton2Cmd );
 }
 }
 // ---------------------------------------------------------
 {
 if ( aCommand != iAllPreferences.iToolbarButton3Cmd )
 {
 iAllPreferences.iToolbarButton3Cmd = aCommand;
 SetIntValueL( KToolbarButton3Cmd, iAllPreferences.iToolbarButton3Cmd );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarButton3Cmd );
 }
 }
 // ---------------------------------------------------------
 {
 if ( aCommand != iAllPreferences.iToolbarButton4Cmd )
 {
 iAllPreferences.iToolbarButton4Cmd = aCommand;
 SetIntValueL( KToolbarButton4Cmd, iAllPreferences.iToolbarButton4Cmd );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarButton4Cmd );
 }
 }
 // ---------------------------------------------------------
 {
 if ( aCommand != iAllPreferences.iToolbarButton5Cmd )
 {
 iAllPreferences.iToolbarButton5Cmd = aCommand;
 SetIntValueL( KToolbarButton5Cmd, iAllPreferences.iToolbarButton5Cmd );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarButton5Cmd );
 }
 }
 // ---------------------------------------------------------
 {
 if ( aCommand != iAllPreferences.iToolbarButton6Cmd )
 {
 iAllPreferences.iToolbarButton6Cmd = aCommand;
 SetIntValueL( KToolbarButton6Cmd, iAllPreferences.iToolbarButton6Cmd );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarButton6Cmd );
 }
 }
 // ---------------------------------------------------------
 {
 if ( aCommand != iAllPreferences.iToolbarButton7Cmd )
 {
 iAllPreferences.iToolbarButton7Cmd = aCommand;
 SetIntValueL( KToolbarButton7Cmd, iAllPreferences.iToolbarButton7Cmd );
 NotifyObserversL( EPreferencesItemChange,
 TBrCtlDefs::ESettingsToolbarButton7Cmd );
 }
 }
 // ---------------------------------------------------------
 {
 iAllPreferences.iShortcutKey2Cmd = aCommand;
 SetIntValueL( KShortcutKey2Cmd, iAllPreferences.iShortcutKey2Cmd );
 }
 }
 // ---------------------------------------------------------
 // CBrowserPreferences::SetShortcutKey3CmdL()
 // ---------------------------------------------------------
 //
 void CBrowserPreferences::SetShortcutKey3CmdL(TInt aCommand)
 iAllPreferences.iShortcutKeyHashCmd = aCommand;
 SetIntValueL( KShortcutKeyHashCmd, iAllPreferences.iShortcutKeyHashCmd );
 }
 }
 // ----------------------------------------------------------------------------
 // CBrowserPreferences::SetURLSuffixList
 // ----------------------------------------------------------------------------
 //
 void CBrowserPreferences::SetURLSuffixList( HBufC* aSetting )
 {
 LOG_ENTERFN("CBrowserPreferences::SetUpdateHoursDefined");
 SetStringValueL ( KBrowserUrlSuffix, aSetting->Des() );
 TPtr ptr = iAllPreferences.iUrlSuffixList->Des();
 ptr.Copy( aSetting->Des() );
 }

changeset 19	16a119033e3e
parent 18	4530440261a8
child 22	d6f226a5ad2c