diff -r 159fc2f68139 -r d59c248c9d36 ImagePrint/ImagePrintUI/imageprinteng/src/csettingsmanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ImagePrint/ImagePrintUI/imageprinteng/src/csettingsmanager.cpp	Wed Sep 01 12:30:38 2010 +0100
@@ -0,0 +1,691 @@
+/*
+* Copyright (c) 2004-2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  
+*
+*/
+
+
+#include <fbs.h>
+#include <eikenv.h>
+#include <e32std.h>
+
+#include "tprintcapability.h"
+#include "csettingsmanager.h"
+#include "ctemplatesettings.h"
+#include "cprintsettings.h"
+#include "ctintcapability.h"
+#include "clistcapability.h"
+#include "cfloatcapability.h"
+#include "ctemplatedata.h"
+#include "printcapabilitycodes.h"
+#include "settingsconverter.h"
+#include "crealfactory.h"
+#include "imageprint.h"
+#include "cimageprint.h"
+#include "imageprintvariant.h"
+#include <centralrepository.h>
+#include "imageprintprivatecrkeys.h"
+#include "mdiscovery.h"
+#include "clog.h"
+
+namespace
+    {
+    const TInt KDefaultPrinterNameMaxLength = 100;
+    const TInt KTemplateSize = 16;
+    const TInt KTemplates[] = {1554,1552,1565,1555,1501,1553,1551,1558,1502,1504,1564,1506,1509,1512,1513,1516};
+    }
+
+#include "clog.h"
+
+// CONSTRUCTION
+CSettingsManager* CSettingsManager::NewL(
+    CRealFactory* aFactory )
+    {
+    CSettingsManager* self = CSettingsManager::NewLC(
+        aFactory );
+    CleanupStack::Pop();    // self
+
+    return self;
+    }
+
+CSettingsManager* CSettingsManager::NewLC(
+    CRealFactory* aFactory )
+    {
+    CSettingsManager* self =
+        new ( ELeave ) CSettingsManager( aFactory );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+
+    return self;
+    }
+
+// Constrcutor
+CSettingsManager::CSettingsManager(
+    CRealFactory* aFactory ) :
+      iFactory( aFactory ),
+      iActivePage( 1 )
+    {
+    }
+
+// Destructor
+CSettingsManager::~CSettingsManager()
+    {
+    delete iPrintSettings;
+    delete iTemplateSettings;
+    delete iCurrentPrinterName;
+    delete iCRSession;
+    iNumberOfCopiesArray.Close();
+    iNumberOfCopiesCumulativeArray.Close();
+    }
+
+// 2nd phase constructor
+void CSettingsManager::ConstructL()
+    {
+    iPrintSettings = new ( ELeave ) CPrintSettings;
+    iTemplateSettings = CTemplateSettings::NewL( iFactory );
+
+    iCRSession  = CRepository::NewL( KCRUidImagePrint );
+    }
+
+// Clones the current template settings
+CTemplateSettings* CSettingsManager::TemplateSettingsL()
+    {
+    return iTemplateSettings->CloneL();
+    }
+
+// Changes active template to a new one
+void CSettingsManager::SetActiveTemplateL(
+    TUint aUid )
+    {
+    LOG1( "CSettingsManager::SetActiveTemplateL START || aUid = %d", aUid );
+    // Set active template to preview manager, if one available
+    iTemplateSettings->iActiveTemplateUid = aUid;
+
+    CListCapability* capab = static_cast<CListCapability*>(
+        FetchCapabilityL( EPrintCapabLayout ) );
+    capab->iValue = aUid;
+    LOG1( "CSettingsManager::SetActiveTemplateL || iImagesOnPage = %d", iImagesOnPage );
+    }
+
+// Returns the number of pages
+TUint CSettingsManager::NumOfPagesL()
+    {
+    // Always 1, fix this for the release 2
+    // return iFactory->Engine()->GetNumPrintPages();
+
+    TInt num( 1 );
+    return num;
+    }
+
+// Returns the number of copies
+TInt CSettingsManager::NumberOfCopies( RArray<TInt>& aArray )
+    {
+    TInt err( KErrNone );
+    aArray.Reset();
+    for( TInt i=0; i<iNumberOfCopiesArray.Count(); ++i )
+        {
+        err = aArray.Append( iNumberOfCopiesArray[ i ] );
+        if( err != KErrNone )
+            {
+            return err;
+            }
+        }
+    return KErrNone;
+    }
+
+TInt CSettingsManager::NumberOfCopies( TInt& aNumberOfCopies, TInt aIndex )
+    {
+    if( -1 < aIndex && aIndex < iNumberOfCopiesArray.Count() )
+        {
+        aNumberOfCopies = iNumberOfCopiesArray[ aIndex ];
+        return KErrNone;
+        }
+    else
+        {
+        return KErrArgument;
+        }
+    }
+
+// Sets the number of copies
+TInt CSettingsManager::SetNumberOfCopiesL( const RArray<TInt>& aArray )
+    {
+    TInt err( KErrNone );
+    TInt numberOfCopiesCumulative( 1 );
+    iNumberOfCopiesArray.Close();
+    iNumberOfCopiesCumulativeArray.Close();
+    for( TInt i=0; i<aArray.Count(); ++i )
+        {
+        err = iNumberOfCopiesArray.Append( aArray[ i ] );
+        if( err != KErrNone )
+            {
+            return err;
+            }
+        err = iNumberOfCopiesCumulativeArray.Append( numberOfCopiesCumulative );
+        numberOfCopiesCumulative += aArray[ i ];
+        if( err != KErrNone )
+            {
+            return err;
+            }
+        }
+    return err;
+    }
+
+TInt CSettingsManager::UpdateNumberOfCopiesToServer()
+    {
+    return iFactory->Engine()->SetNumberOfCopies( iNumberOfCopiesArray );
+    }
+
+// Returns
+TBool CSettingsManager::IsMMC()
+    {
+    TBool retVal = EFalse;
+    TInt supportedProtocols = iFactory->DiscoveryIF()->SupportedProtocols();
+
+	if( (supportedProtocols & KImagePrint_PrinterProtocol_DPOF)  && 
+    	( iPrinterUid == iMMCUid ))
+		{
+		retVal = ETrue;
+		}
+	LOG1( "CSettingsManager::IsMMC: %d ", retVal );
+    return retVal;
+    }
+
+// Changes active page for drawing a new preview
+void CSettingsManager::SetActivePageL(
+    TUint aActivePage )
+    {
+    }
+
+// Returns current active page
+TUint CSettingsManager::CurActivePageL()
+    {
+    TUint num( 1 );
+    return num;
+    }
+
+// Clones current print settings
+CPrintSettings* CSettingsManager::PrinterSettingsL()
+    {
+    return iPrintSettings->CloneL();
+    }
+
+// Sets all settings, not supported at the moment
+void CSettingsManager::SetPrinterSettingsL(
+    CPrintSettings& /*aSettings*/ )
+    {
+    User::Leave( KErrNotSupported );
+    }
+
+// Sets a single setting
+TInt CSettingsManager::SetPrinterSettingL(
+    CBaseCapability& aCapab )
+    {
+    LOG( "CSettingsManager::SetPrinterSettingL START" );
+    TInt getSettings( 0 );
+    TInt err = iFactory->Engine()->SetJobSettingL(
+        aCapab.iUid, aCapab.iValue, getSettings );
+    getSettings  = 0;
+    User::LeaveIfError( err );
+
+    CBaseCapability* capab = FetchCapabilityL( aCapab.iUid );
+    capab->iValue = aCapab.iValue;
+
+#ifdef IMG_PRINT_DYNAMIC_PRINT_SETTINGS
+    // Do not initialize if only template was changed
+    if( aCapab.iUid != 500 )
+        {
+        LOG( "CSettingsManager::SetPrinterSettingL || aCapab.iUid != 500" );
+        InitCapabilitiesL( iPrinterUid );
+        InitTemplateSettingsL();
+        }
+     else
+        {
+        LOG( "CSettingsManager::SetPrinterSettingL || aCapab.iUid == 500" );
+        SetActiveTemplateL( aCapab.iValue );
+        }
+#else
+     InitCapabilitiesL( iPrinterUid );
+     InitTemplateSettingsL();
+#endif
+
+    LOG1( "CSettingsManager::SetPrinterSettingL getSettings = %d", getSettings );
+    return getSettings;
+    }
+
+// Initializes the printer settings
+void CSettingsManager::InitSettingsL(
+    TInt aPrinterUid,
+    TInt aMMCUid )
+    {
+    LOG1( "CSettingsManager::InitSettingsL aPrinterUid = %d", aPrinterUid );
+    LOG1( "CSettingsManager::InitSettingsL aMMCUid     = %d", aMMCUid     );
+    
+    iMMCUid = aMMCUid;
+    InitCapabilitiesL( aPrinterUid );
+    InitTemplateSettingsL();
+    iPrinterUid = aPrinterUid;
+    }
+
+// Inititalizes the capabilities
+void CSettingsManager::InitCapabilitiesL(
+    TInt aPrinterUid )
+    {
+    LOG1("CSettingsManager::InitCapabilitiesL Begin: %d", aPrinterUid);
+    RArray<TInt> capabIDs;
+    CleanupClosePushL( capabIDs );
+
+    // Get list of IDs
+    iFactory->Engine()->GetPrinterCapabilityIDsL( aPrinterUid, capabIDs );
+    CPrintSettings* printSettings = new ( ELeave ) CPrintSettings;
+    CleanupStack::PushL( printSettings );
+
+    TInt i( 0 );
+    TInt num( capabIDs.Count() );
+    LOG1("CSettingsManager::InitCapabilitiesL number of capabs: %d", num);
+    for ( i = 0; i < num; i++ )
+        {
+        TPrintCapability capab;
+        iFactory->Engine()->GetPrinterCapabilityL( aPrinterUid, capabIDs[i], capab );
+        capab.iType = TPrintCapability::Enum;
+
+        CBaseCapability* capability = 0;
+
+        // Create capability
+        switch ( capab.iType )
+            {
+            case TPrintCapability::Int:
+                capability = SettingsConverter::AddTIntCapabilityLC(
+                    capab, i, capabIDs[i] );
+                break;
+
+            case TPrintCapability::Enum:
+                capability = SettingsConverter::AddListCapabilityLC(
+                    capab, i, capabIDs[i], iFactory );
+                break;
+
+            case TPrintCapability::Float:
+                capability = SettingsConverter::AddFloatCapabilityLC(
+                    capab, i, capabIDs[i] );
+                break;
+
+            default:
+                User::Leave( KErrUnknown );
+                break;
+            }
+        iFactory->Engine()->GetJobSetting( capabIDs[i], capability->iValue );
+
+        // Add the capability to the list
+        User::LeaveIfError(
+            printSettings->iCapabilities.Append( capability ) );
+        CleanupStack::Pop();    // capability
+        }
+
+    delete iPrintSettings;
+    iPrintSettings = printSettings;
+
+    CleanupStack::Pop();    // printSettings
+    CleanupStack::PopAndDestroy();  // capabIDs
+    LOG("CSettingsManager::InitCapabilitiesL End");
+    }
+
+// Initializes the templates
+void CSettingsManager::InitTemplateSettingsL()
+    {
+    LOG("CSettingsManager::InitTemplateSettingsL Begin");
+    CTemplateSettings* settings = CTemplateSettings::NewL( iFactory );
+    CleanupStack::PushL( settings );
+    TInt templateBuffer = iFactory->SettingsIF()->TemplateUid();
+
+    TInt i( 0 );
+    TInt num( iPrintSettings->iCapabilities.Count() );
+    for ( i = 0; i < num; i++ )
+        {
+        if ( iPrintSettings->iCapabilities[i]->iUid == EPrintCapabLayout )
+            {
+            TInt j( 0 );
+            CListCapability* layouts =
+                static_cast<CListCapability*>
+                        ( iPrintSettings->iCapabilities[i] );
+            for ( j = 0; j < layouts->iEnumIDs.Count(); j++ )
+                {
+                // Create new template data with the icon and Uid value
+                CTemplateData* data = CTemplateData::NewL();
+                data->iUid = layouts->iEnumIDs[j];
+                CleanupStack::PushL( data );
+                LOG1( "CSettingsManager::InitTemplateSettingsL, UID: %d", data->iUid );
+                User::LeaveIfError( settings->iTemplates.Append( data ) );
+                CleanupStack::Pop( data );
+                }
+            }
+        }
+
+    // Sort the templates to "standard" order
+    CTemplateSettings* sortsettings = CTemplateSettings::NewL( iFactory );
+    CleanupStack::PushL( sortsettings );
+    for ( TInt i = 0; i < KTemplateSize; i++ )
+        {
+        for ( TInt j = 0; j < settings->iTemplates.Count(); j++ )
+            {
+            if ( KTemplates[i] == settings->iTemplates[j]->iUid )
+                {
+                CTemplateData* data = CTemplateData::NewL();
+                data->iUid = settings->iTemplates[j]->iUid;
+                CleanupStack::PushL( data );
+                LOG1( "CSettingsManager::InitTemplateSettingsL, UID: %d", data->iUid );
+                User::LeaveIfError( sortsettings->iTemplates.Append( data ) );
+                CleanupStack::Pop( data );
+                break;
+                }
+            }
+        }
+
+    CleanupStack::Pop( sortsettings );
+    CleanupStack::PopAndDestroy( settings );
+    delete iTemplateSettings;
+    iTemplateSettings = sortsettings;
+
+    TBool templateFound = EFalse;
+    if ( iTemplateSettings->iTemplates.Count() > 0 )
+        {
+        for (TInt g = 0; g < iTemplateSettings->iTemplates.Count(); g++) 
+        	{
+	        if (iTemplateSettings->iTemplates[g]->iUid == templateBuffer)
+	        	{
+	        		iTemplateSettings->iActiveTemplateUid = templateBuffer;
+	        		templateFound = ETrue;
+	        	}
+        	}
+        if (!templateFound){
+        iTemplateSettings->iActiveTemplateUid = 
+        iTemplateSettings->iTemplates[0]->iUid;
+        }
+        
+        SetActiveTemplateL( iTemplateSettings->iActiveTemplateUid );
+        }
+    // If there are no templates available, draw the preview using
+    // 1/page template
+    else
+        {
+        LOG("CSettingsManager::InitTemplateSettingsL || No templates available!");
+        SetActiveTemplateL( EPrintCapabLayout1UpMedium );
+        }
+    LOG("CSettingsManager::InitTemplateSettingsL End");
+    }
+
+// Fetches capability from the list and returns it
+CBaseCapability* CSettingsManager::FetchCapabilityL(
+    TInt aUid )
+    {
+    LOG1("CSettingsManager::FetchCapabilityL Begin: %d", aUid);
+    CBaseCapability* capab = NULL;
+    TInt found( KErrNotFound );
+
+    TInt i( 0 );
+    TInt num( iPrintSettings->iCapabilities.Count() );
+    for ( i = 0; i < num && found != KErrNone; i++ )
+        {
+        if ( iPrintSettings->iCapabilities[i]->iUid == aUid )
+            {
+            capab = iPrintSettings->iCapabilities[i];
+            found = KErrNone;
+            }
+        }
+
+    User::LeaveIfError( found );
+    LOG("CSettingsManager::FetchCapabilityL End");
+    return capab;
+    }
+
+TInt CSettingsManager::TemplateUid()
+    {
+    LOG1( "CSettingsManager::TemplateUid || iActiveTemplateUid = %d", iTemplateSettings->iActiveTemplateUid );
+    return iTemplateSettings->iActiveTemplateUid;
+    }
+
+TBool CSettingsManager::UpdatePageNumberL( TInt aCurrentImage )
+    {
+    TBool retValue = EFalse;
+    TUint pageNumber;
+
+    if( iNumberOfCopiesCumulativeArray.Count() > aCurrentImage-1 )
+        {
+        aCurrentImage = iNumberOfCopiesCumulativeArray[aCurrentImage-1];
+        }
+
+    pageNumber = aCurrentImage / iImagesOnPage;
+    if ( ( aCurrentImage % iImagesOnPage ) != 0 )
+        {
+        pageNumber++;
+        }
+
+    if ( iActivePage != pageNumber )
+        {
+        iActivePage = pageNumber;
+        retValue = ETrue;
+        }
+    return retValue;
+    }
+
+TInt CSettingsManager::PrinterUid()
+    {
+    return iPrinterUid;
+    }
+
+
+TBool CSettingsManager::GetUsbState()
+    {
+    return iUsbConnected;
+    }
+
+void CSettingsManager::SetUsbState( TBool aConnected )
+    {
+    iUsbConnected = aConnected;
+    }
+
+TInt CSettingsManager::GetDefaultPrinterProtocol()
+    {
+    TInt retValue;
+    TInt err = iCRSession->Get( KDefaultPrinterProtocol, retValue );
+
+    LOG2("CSettingsManager::GetDefaultPrinterProtocol: %d, err: %d", retValue, err);
+    return ( err ) ? err : retValue;
+    }
+
+
+TInt CSettingsManager::SetDefaultPrinterProtocol( TInt aProtocol )
+    {
+    TInt err = iCRSession->Set( KDefaultPrinterProtocol, aProtocol );
+    LOG2("CSettingsManager::SetDefaultPrinterProtocol: %d, err: %d", aProtocol, err);
+    return err;
+    }
+
+TInt CSettingsManager::GetCurrentPrinterProtocol()
+    {
+    LOG1("CSettingsManager::GetCurrentPrinterProtocol: %d", iCurrentPrinterProtocol );
+    return iCurrentPrinterProtocol;
+    }
+
+void CSettingsManager::SetCurrentPrinterProtocol( TInt aProtocol )
+    {
+    LOG1("CSettingsManager::SetCurrentPrinterProtocol: %d", aProtocol );
+    iCurrentPrinterProtocol = aProtocol;
+    }
+
+TUint CSettingsManager::GetCurrentPrinterVendor()
+    {
+    LOG1("CSettingsManager::GetCurrentPrinterVendor() vendor: %d",iVendor);
+    return iVendor;
+    }
+
+void CSettingsManager::SetCurrentPrinterVendor( TUint aVendor )
+    {
+    LOG1("CSettingsManager::SetCurrentPrinterVendor() vendor: %d",aVendor);
+    iVendor = aVendor;
+    }
+
+TInt CSettingsManager::GetDefaultPrintID()
+    {
+    TInt retValue;
+    TInt err = iCRSession->Get( KDefaultPrinterID, retValue );
+    LOG2("CSettingsManager::GetDefaultPrintID: get: %d, err: %d", retValue, err);
+    return ( err ) ? err : retValue;
+    }
+
+TInt CSettingsManager::SetDefaultPrinterID( TInt aId )
+    {
+    TInt err = iCRSession->Set( KDefaultPrinterID, aId );
+    LOG2("CSettingsManager::SetDefaultPrinterID: set: %d, err: %d", aId, err);
+    return err;
+    }
+
+HBufC* CSettingsManager::GetDefaultPrinterNameLC()
+    {
+    HBufC* name = HBufC::NewLC( KDefaultPrinterNameMaxLength );
+    TPtr ptr( name->Des() );
+    TInt err = iCRSession->Get( KDefaultPrinterName, ptr );
+    LOG2("CSettingsManager::GetDefaultPrinterNameLC: name: %S, err: %d", &ptr, err);
+    return name;
+    }
+
+TInt CSettingsManager::SetDefaultPrinterNameL( const TDesC& aPrinterName )
+    {
+    TInt err = KErrNone;
+    HBufC* stringholder = HBufC::NewLC( aPrinterName.Length() );
+        *stringholder = aPrinterName;
+
+        // Clear the printer name string from all formatting tabs & numbers
+        TPtr ptr = stringholder->Des();
+        TInt pos = stringholder->Find( KTabChar );
+        if ( pos == 1 ) // 1st possible icon formatting tab is at pos 1
+            {
+            ptr.Delete( 0, 2 ); // delete the first icon tab and the number previous to it
+            pos = stringholder->Find( KTabChar );
+            }
+        while ( pos != KErrNotFound &&
+                pos != stringholder->Length() - 2 )
+            {
+            ptr.Delete( pos, 1); // delete all middle tabs
+            pos = stringholder->Find( KTabChar );
+            }
+        // 2nd possible iconformatting tab is 2nd last char
+        if ( pos != KErrNotFound &&
+             pos == stringholder->Length() - 2 )
+            {
+            // delete the 2nd icon formatting tab and the number next to it
+            ptr.Delete( stringholder->Length() - 2, 2 );
+            }
+
+        err = iCRSession->Set( KDefaultPrinterName, *stringholder );
+        LOG2("CSettingsManager::SetDefaultPrinterNameL: name: %S err: %d", &ptr, err);
+        CleanupStack::PopAndDestroy( stringholder );
+    return err;
+    }
+
+HBufC* CSettingsManager::GetCurrentPrinterName()
+    {
+    TPtr ptr = iCurrentPrinterName->Des();
+    LOG1("CSettingsManager::GetCurrentPrinterName: name: %S",  &ptr );
+    return iCurrentPrinterName;
+    }
+
+TInt CSettingsManager::SetCurrentPrinterName( const TDesC& aPrinterName )
+    {
+    if( iCurrentPrinterName )
+        {
+        delete iCurrentPrinterName;
+        iCurrentPrinterName = NULL;
+        }
+    
+    TInt err;
+    HBufC* tmpBuf = aPrinterName.Alloc();
+    if( !tmpBuf )
+        {
+        return KErrGeneral;
+        }
+    else
+        {
+        err = KErrNone;    
+        iCurrentPrinterName = tmpBuf;
+        }        
+    
+    // Clear the printer name string from all formatting tabs & numbers
+    TPtr ptr = iCurrentPrinterName->Des();
+    TInt pos = iCurrentPrinterName->Find( KTabChar );
+    if ( pos == 1 ) // 1st possible icon formatting tab is at pos 1
+        {
+        ptr.Delete( 0, 2 ); // delete the first icon tab and the number previous to it
+        pos = iCurrentPrinterName->Find( KTabChar );
+        }
+    while ( pos != KErrNotFound &&
+            pos != iCurrentPrinterName->Length() - 2 )
+        {
+        ptr.Delete( pos, 1); // delete all middle tabs
+        pos = iCurrentPrinterName->Find( KTabChar );
+        }
+    // 2nd possible iconformatting tab is 2nd last char
+    if ( pos != KErrNotFound &&
+         pos == iCurrentPrinterName->Length() - 2 )
+        {
+        // delete the 2nd icon formatting tab and the number next to it
+        ptr.Delete( iCurrentPrinterName->Length() - 2, 2 );
+        }
+
+    LOG1("CSettingsManager::SetCurrentPrinterName: name: %S", &ptr );
+    return err;
+    }
+    
+HBufC* CSettingsManager::GetCurrentPaperSizeTextL()
+    {    
+    HBufC* retValue = NULL;
+    CListCapability* paperSizeCapab = NULL;
+    // Searches the paper size capability from the capability list
+    // Search the UID for paper size (= 4)
+    TInt counter = iPrintSettings->iCapabilities.Count();
+    for( TInt i = 0 ; i < counter ; i++ )
+        {
+
+        //Use the searched ListCapability
+        if( iPrintSettings->iCapabilities[ i ]->iUid == EPrintCapabPaperSize )
+            {
+            paperSizeCapab = static_cast< CListCapability* >
+                                   ( iPrintSettings->iCapabilities[ i ] );
+            }
+        }
+    
+    
+    TBool found( EFalse );
+
+    if ( paperSizeCapab )
+        {
+        const TInt expectedNumberOfStrings( 2 );
+        CDesCArrayFlat* strings = 
+            new ( ELeave ) CDesCArrayFlat( expectedNumberOfStrings );
+        CleanupStack::PushL( strings );
+
+        TInt i( 0 );
+        TInt counter = paperSizeCapab->iEnumIDs.Count();
+        for ( i = 0; i < counter && !found; i++ )
+            {
+            if ( paperSizeCapab->iEnumIDs[i] ==
+                 paperSizeCapab->iValue )
+                {
+                retValue = paperSizeCapab->iTexts[i];
+                }
+            }
+        CleanupStack::PopAndDestroy();	// strings
+        }
+    return retValue;
+    }
+
+//  End of File