1 /*

     2 * Copyright (c) 2002-2007 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:  Contains the CPBPrintingDevice class definition.

    15 *

    16 */

    17 

    18 

    19 #include <e32std.h>

    20 #include <pictbridge.h>

    21 #include <s32file.h>

    22 #include <f32file.h>

    23 

    24 #include "cpbprintingdevice.h"

    25 #include "printcapabilitycodes.h"

    26 #include "printmessagecodes.h"

    27 #include "imageprint.h"

    28 #include "cpbconnect.h"

    29 #include "clog.h"

    30 

    31 //  CONSTANTS

    32 namespace

    33 	{

    34 	const TInt KPBVersionMajor = 0;

    35 	const TInt KPBVersionMinor = 0;

    36 	const TInt KPBVersionBuild = 1;

    37 	}

    38 

    39 const TInt KConfigLength = 16;

    40 const TInt KMaxRetry = 10;

    41 _LIT( KConfigInfoFile, "config.DPS");

    42 

    43 

    44 MProtPrintingDevice* CPBPrintingDevice::NewL()

    45 	{

    46 	return new (ELeave) CPBPrintingDevice();

    47 	}

    48 

    49 

    50 CPBPrintingDevice::CPBPrintingDevice() :

    51 CActive( CActive::EPriorityStandard ), iState(EPBUninitialized), iDisconnectPrinter(EFalse)

    52 	{

    53 	CActiveScheduler::Add(this);

    54 	}

    55 

    56 void CPBPrintingDevice::ConstructL(const TDesC& /*aDLLPath*/)

    57 	{

    58 	LOG("CPBPrintingDevice::ConstructL begin");	

    59 	

    60 	iDpsEngine = CDpsEngine::GetEngineL();		

    61 	iConnect = CPBConnect::NewL( *iDpsEngine, *this );

    62 	

    63     iCongFileName = HBufC::NewL( iDpsEngine->DpsFolder().Length() + KConfigLength );

    64     TInt k = iDpsEngine->DpsFolder().Length() + KConfigLength;

    65     iCongFileName->Des().Copy( iDpsEngine->DpsFolder() );

    66     iCongFileName->Des().Append( KConfigInfoFile );

    67  	

    68 	iCancelRetry = 0;

    69 

    70     // for Cert software to indicate that printing state and idle state 

    71     iPrintingStateComplete = 0;

    72 	

    73 	iUserSelectedPaperSize = EDpsPaperSizeDefault;

    74 	iNewJobOK = ETrue;

    75 	

    76 	LOG("CPBPrintingDevice::ConstructL end");

    77 	}

    78 

    79 

    80 CPBPrintingDevice::~CPBPrintingDevice()

    81 	{

    82 	LOG("CPBPrintingDevice::~CPBPrintingDevice begin");

    83 	Cancel();

    84 	delete iConnect;

    85 	delete iCongFileName;

    86 	if ( iDpsEngine )

    87 		{

    88 		iDpsEngine->Delete();

    89 		}

    90 	REComSession::DestroyedImplementation( iDtor_ID_Key );

    91 	LOG("CPBPrintingDevice::~CPBPrintingDevice end");

    92 	}

    93 

    94 

    95 TVersion CPBPrintingDevice::Version()

    96 	{

    97 	return TVersion(KPBVersionMajor, KPBVersionMinor, KPBVersionBuild);

    98 	}

    99 

   100 TUint CPBPrintingDevice::SupportedProtocols()

   101 	{

   102 	return KImagePrint_PrinterProtocol_PictBridge;

   103 	}

   104 

   105 void CPBPrintingDevice::StartDiscoveryL(MProtDiscoveryObserver& aObserver, TUint aProtocol)

   106 	{		

   107 	LOG1("CPBPrintingDevice::StartDiscoveryL aProtocol: %d", aProtocol);

   108 	iDiscoveryObserver = &aObserver;

   109 		

   110 	if ( IsActive() )

   111 		{

   112 		LOG1("CPBPrintingDevice::StartDiscoveryL invalid state %d, cannot start discovery", iState);

   113 		iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrInvalidSequence, 0 );

   114 		return;

   115 		}

   116 				

   117 	if ( !( aProtocol & KImagePrint_PrinterProtocol_PictBridge ) )

   118 		{

   119 		LOG("CPBPrintingDevice::StartDiscoveryL NO protocol match, ending discovery...");

   120 		iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNotSupported, 0 );

   121 		return;

   122 		}

   123 

   124 	if ( !iPrinterConnected )

   125 		{

   126 		LOG("CPBPrintingDevice::StartDiscoveryL no printer connected, ending discovery");

   127 		iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 );

   128 		return;

   129 		}

   130 

   131 

   132 	// clear capability map

   133 	iCapToDps.Close();

   134 

   135     iConfigS.iReqParam.Reset();

   136     iDpsEngine->GetDpsConfigL( iConfigS.iReqParam );

   137     iDpsEngine->DoDpsRequestL( &iConfigS, iStatus );

   138 	iState = EPBDiscovery;

   139     SetActive();

   140 	LOG("CPBPrintingDevice::StartDiscoveryL setting state to Discovery");

   141 		

   142 	LOG("CPBPrintingDevice::StartDiscoveryL end");

   143 	}

   144 

   145 

   146 TInt CPBPrintingDevice::RemoveCachedDeviceL( TInt aDeviceID )

   147 	{

   148   	LOG1("CPBPrintingDevice::RemoveCachedDeviceL, aDeviceID: %d", aDeviceID);

   149   	return KErrInvalidData;

   150 	}

   151 

   152 void CPBPrintingDevice::CancelDiscovery( TBool aDoCallBack )

   153 	{

   154   	LOG2("CPBPrintingDevice::CancelDiscovery aDoCallBack %d, iState %d", aDoCallBack, iState );  	

   155   	if ( iState == EPBDiscovery )

   156 	  	{

   157 	  	Cancel();

   158 		if ( aDoCallBack && iDiscoveryObserver )

   159 			{

   160 			//We're not interested if the call back leaves

   161 			TRAP_IGNORE( iDiscoveryObserver->DiscoveryStatusL( EDiscoveryCancelling, KErrNone, 0 ) );

   162 			//We're not interested if the call back leaves

   163 			TRAP_IGNORE( iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 ) );

   164 			}

   165 		iState = EPBUninitialized;

   166 	  	}  	

   167 	LOG("CPBPrintingDevice::CancelDiscovery end");

   168 	}

   169 

   170 

   171 TInt CPBPrintingDevice::CreatePrintJobL(TInt aDeviceID, RPointerArray<TDesC>& aImages, MProtPrintEventObserver& aObserver)

   172 	{

   173   	LOG2("CPBPrintingDevice::CreatePrintJobL begin, deviceid %d imagecount %d", aDeviceID, aImages.Count());

   174 	iPrintEventObserver = &aObserver;		

   175 

   176 	if ( aDeviceID != 0 )

   177 		{

   178 		LOG("CPBPrintingDevice::CreatePrintJobL invalid device");

   179 		return KErrArgument;

   180 		}

   181 		

   182 	if ( iState != EPBReady && iState != EPBJobReady )

   183 		{

   184 		LOG1("CPBPrintingDevice::CreatePrintJobL invalid state %d", iState);

   185 		if(iDisconnectPrinter) // If printer is disconnected then return KErrDisconnected.

   186 			return KErrDisconnected;

   187 		else 

   188 			return KErrInvalidSequence;

   189 		}

   190 		

   191     iStart.iReqParam.Reset();                                                                               

   192 		

   193 	// these must be appended in same order as PBJobSettingIndex

   194 	

   195     TDpsArgsInt arg;    

   196     arg.iElement = EDpsArgPaperSize;

   197     arg.iContent = EDpsPaperSizeDefault;

   198     iStart.iReqParam.iJobConfig.Append(arg);

   199 

   200     arg.iElement = EDpsArgQuality;

   201     arg.iContent = EDpsPrintQualityDefault;

   202     iStart.iReqParam.iJobConfig.Append(arg);

   203 				

   204     arg.iElement = EDpsArgLayout;

   205     arg.iContent = EDpsLayoutDefault;

   206     iStart.iReqParam.iJobConfig.Append(arg);

   207                         	

   208 	for ( TInt i = 0; i < aImages.Count(); ++i )

   209 		{

   210 	    TDpsPrintInfo info;

   211 	    info.Reset();

   212 	    const TDesC& image = *aImages[i];

   213 	    LOG1("CPBPrintingDevice::CreatePrintJobL image %S", &image);

   214 	    info.iFile.Copy( image );

   215 	    iStart.iReqParam.iPrintInfo.Append( info );

   216 		}

   217 

   218 	LOG("CPBPrintingDevice::CreatePrintJobL setting state to JobReady");

   219 	iState = EPBJobReady;

   220 	

   221 	LOG("CPBPrintingDevice::CreatePrintJobL end");

   222 	return KErrNone;

   223 	}

   224 

   225 void CPBPrintingDevice::SubmitPrintJobL()

   226 	{

   227 	LOG("CPBPrintingDevice::SubmitPrintJobL begin");

   228 

   229 	// Checking that job is ready and printer has send aStatus.iRepParam.iNewJobOk

   230 	// Check PrinterNotify function

   231 	if ( iState == EPBJobReady && iNewJobOK )

   232 		{

   233 		iDpsEngine->DoDpsRequestL( &iStart, iStatus );

   234 		iState = EPBSubmittingJob;

   235 		SetActive();

   236 		LOG("CPBPrintingDevice::SubmitPrintJobL setting state to SubmittingJob");

   237 		}

   238 	else

   239 		{

   240 		LOG1("CPBPrintingDevice::SubmitPrintJobL invalid state %d", iState);

   241 		if( iDisconnectPrinter )

   242 		    {

   243 		    User::Leave( KErrDisconnected );

   244 		    }

   245 		else

   246 		    {

   247 		  	// Job or printer not ready, inform user

   248 		  	if( iPrintEventObserver )

   249 		  	    {

   250     		  	LOG("CPBPrintingDevice::SubmitPrintJobL sending EPbStatusErrorReasonHardwarePrinterBusy message to UI");

   251     		  	iPrintEventObserver->PrinterStatusEvent( EPbStatusErrorReasonHardwarePrinterBusy );

   252 		  	    }

   253 		    else

   254 		        {

   255        			LOG1("CPBPrintingDevice::SubmitPrintJobL invalid state %d", iState);

   256        			User::Leave( KErrInvalidSequence );

   257 		        }

   258 		    }

   259 		

   260 		}

   261 	

   262 	LOG("CPBPrintingDevice::SubmitPrintJobL end");

   263 	}

   264 

   265 TInt CPBPrintingDevice::CancelPrintJob()

   266 	{

   267 	LOG("CPBPrintingDevice::CancelPrintJob begin");

   268 

   269     if( iCancelRetry > KMaxRetry )

   270         {

   271         return KErrInUse;

   272         }

   273 	

   274 	if ( iState == EPBSubmittingJob || iState == EPBPrinting || iState == EPBCancelling )

   275 		{

   276         Cancel();

   277         iAbort.iReqParam.iAbortStyle = EDpsAbortStyleImmediately;

   278         TRAPD( err, iDpsEngine->DoDpsRequestL( &iAbort, iStatus ) );

   279         if ( err != KErrNone )

   280 	        {

   281 	        LOG1("CPBPrintingDevice::CancelPrintJob FATAL, DoDpsRequestL failed %d, setting state to Uninitialized", err);

   282 	       	iState = EPBUninitialized;

   283 	       	return KErrGeneral;

   284 	        }        

   285         iState = EPBCancelling;

   286         SetActive();

   287         LOG("CPBPrintingDevice::CancelPrintJob setting state to Cancelling");

   288 		}	

   289 	else if ( iState == EPBJobReady )

   290 		{

   291 		LOG("CPBPrintingDevice::CancelPrintJob state is JobReady so doing nothing");

   292 		return KErrNone;

   293 		}

   294 	else 

   295 		{

   296 		LOG1("CPBPrintingDevice::CancelPrintJob invalid state %d", iState);

   297 		return KErrInvalidSequence;

   298 		}

   299 		

   300 	LOG("CPBPrintingDevice::CancelPrintJob end");

   301 	return KErrNone;

   302 	}

   303 

   304 TInt CPBPrintingDevice::ContinuePrintJobL()

   305 	{

   306 	LOG1("CPBPrintingDevice::ContinuePrintJobL returns with: %d", KErrNotSupported);

   307 	return KErrNotSupported;

   308 	}

   309 

   310 TInt CPBPrintingDevice::GetNumPrintPages()

   311 	{

   312 	LOG("CPBPrintingDevice::GetNumPrintPages begin");

   313 	

   314 	if ( iState != EPBJobReady && iState != EPBSubmittingJob && iState != EPBPrinting )

   315 		{

   316 		LOG1("CPBPrintingDevice::GetNumPrintPages invalid state %d, returning 0", iState);

   317 		return 0;

   318 		}

   319 

   320 	TInt imagesPerPage = 1;

   321 	TDpsArgsInt& config = iStart.iReqParam.iJobConfig[EPBSettingLayout];

   322 	switch ( config.iContent )

   323 		{        

   324         case EDpsLayout2Up:

   325 			imagesPerPage = 2;

   326         	break;        

   327         case EDpsLayout4Up:

   328 			imagesPerPage = 4;

   329         	break;        

   330         case EDpsLayout6Up:

   331 			imagesPerPage = 6;

   332         	break;        

   333         case EDpsLayout9Up:

   334 			imagesPerPage = 9;

   335         	break;        	        			        		        						

   336 		default:

   337 			break;

   338 		}

   339 

   340 	TInt numPrintPages = (iStart.iReqParam.iPrintInfo.Count() + imagesPerPage - 1) / imagesPerPage;

   341 	LOG1("CPBPrintingDevice::GetNumPrintPages end, result %d", numPrintPages);

   342 	return numPrintPages;

   343 	}

   344 

   345 TInt CPBPrintingDevice::GetPrintJobStatus()

   346 	{

   347 	LOG1("CPBPrintingDevice::GetPrintJobStatus returns with: %d", KErrNotSupported);

   348 	return KErrNotSupported;

   349 	}

   350 

   351 TInt CPBPrintingDevice::GetPrinterStatus(TInt /*aDeviceID*/)

   352 	{

   353 	LOG1("CPBPrintingDevice::GetPrinterStatus returns with: %d", KErrNotSupported);

   354 	return KErrNotSupported;

   355 	}

   356 

   357 TInt CPBPrintingDevice::GetDeviceCapabilityIDsL(TInt aDeviceID, RArray<TInt>& aCapabilityIDs)

   358 	{

   359 	LOG1("CPBPrintingDevice::GetDeviceCapabilityIDsL begins with aDeviceID: %d", aDeviceID);

   360 

   361 	if ( aDeviceID != 0 )

   362 		{

   363 		LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid device");

   364 		return KErrArgument;

   365 		}		

   366 					

   367 	if ( iState != EPBReady && iState != EPBJobReady )

   368 		{

   369 		LOG1("CPBPrintingDevice::GetDeviceCapabilityL invalid state %d", iState);

   370 		return KErrInvalidSequence;

   371 		}	

   372 	

   373 	aCapabilityIDs.Append( EPrintCapabLayout );

   374 	aCapabilityIDs.Append( EPrintCapabQuality );

   375 	aCapabilityIDs.Append( EPrintCapabPaperSize );

   376 		

   377 	LOG("CPBPrintingDevice::GetDeviceCapabilityIDsL end");

   378 	return KErrNone;

   379 	}

   380 

   381 TInt CPBPrintingDevice::GetDeviceCapabilityL(TInt aDeviceID, TInt aCapabilityID, TPrintCapability& aCapability)

   382 	{		

   383 	LOG2("CPBPrintingDevice::GetDeviceCapabilityL begins with aDeviceID %d, aCapabilityID %d", aDeviceID, aCapabilityID);

   384 

   385 	if ( aDeviceID != 0 )

   386 		{

   387 		LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid device");

   388 		return KErrArgument;

   389 		}		

   390 					

   391 	if ( iState != EPBReady && iState != EPBJobReady )

   392 		{

   393 		LOG1("CPBPrintingDevice::GetDeviceCapabilityL invalid state %d", iState);

   394 		return KErrInvalidSequence;

   395 		}	

   396 

   397 	if ( aCapabilityID == EPrintCapabPaperSize )

   398 		{

   399 		// paper sizes

   400 		iCap.iRepParam.Reset();

   401 		iCap.iReqParam.iCap = EDpsArgPaperSizes;

   402 		iDpsEngine->DoDpsRequestL(&iCap, iStatus);

   403 		SetActive();

   404 		iWait.Start();

   405 		HandlePapersizesResponseL( aCapability );

   406 		

   407 		if ( !aCapability.iEnumCount )

   408 			{

   409 			LOG("CPBPrintingDevice::GetDeviceCapabilityL paper sizes not supported, set to default");

   410 	    	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeAuto;

   411 	    	iCapToDps.InsertL( EPrintCapabPaperSizeAuto, EDpsPaperSizeDefault );

   412 			}				    		

   413 	    }

   414 	else if ( aCapabilityID == EPrintCapabQuality )

   415 		{

   416 		// qualities

   417 		LOG("CPBPrintingDevice::GetDeviceCapabilityL qualities");

   418 		iCap.iRepParam.Reset();

   419 		iCap.iReqParam.iCap = EDpsArgQualities;

   420 		iDpsEngine->DoDpsRequestL( &iCap, iStatus );

   421 		SetActive();

   422 		iWait.Start();

   423 		HandleQualitiesResponseL( aCapability );

   424 		}

   425 	else if ( aCapabilityID == EPrintCapabLayout )

   426 		{			

   427 		// layouts		

   428 		LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts");

   429 		iCap.iRepParam.Reset();

   430 		iCap.iReqParam.iCap = EDpsArgLayouts;

   431 		iCap.iReqParam.iAttribute = iUserSelectedPaperSize;

   432 		LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts dodpsrequest");		

   433 		iDpsEngine->DoDpsRequestL(&iCap, iStatus);

   434 		SetActive();

   435 		LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts wait");

   436 		iWait.Start();

   437 		HandleLayoutsResponseL( aCapability );

   438 		}

   439 	else

   440 		{

   441 		LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid capabilityID");

   442 		return KErrArgument;

   443 		}	    

   444 		

   445 	LOG1("CPBPrintingDevice::GetDeviceCapabilityL iCapToDps count %d", iCapToDps.Count());

   446 

   447 	LOG("CPBPrintingDevice::GetDeviceCapabilityL end");

   448 	return KErrNone;

   449 	}

   450 

   451 TInt CPBPrintingDevice::GetJobSetting(TInt aCapabilityID, TInt& aValue)

   452 	{

   453 	LOG1("CPBPrintingDevice::GetJobSetting begin, aCapabilityID %d", aCapabilityID);

   454 

   455 	TInt err = KErrNone;		

   456 	if ( iState != EPBJobReady )

   457 		{

   458 		LOG1("CPBPrintingDevice::GetJobSetting invalid state %d", iState);

   459 		err = KErrInvalidSequence;

   460 		}	

   461 	else if ( aCapabilityID == EPrintCapabPaperSize )

   462 		{

   463 		err = GetPapersizeJobSetting( aValue );

   464 	    }

   465 	else if ( aCapabilityID == EPrintCapabQuality )

   466 		{

   467 		err = GetQualityJobSetting( aValue );

   468 		}

   469 	else if ( aCapabilityID == EPrintCapabLayout )

   470 		{

   471 		err = GetLayoutJobSetting( aValue );

   472 		}

   473 	else

   474 		{

   475 		LOG("CPBPrintingDevice::GetJobSetting invalid capabilityID");

   476 		err = KErrArgument;

   477 		}	    

   478 		

   479 	LOG2("CPBPrintingDevice::GetJobSetting end, return code %d value %d", err, aValue);

   480 	return err;

   481 	}

   482 

   483 TInt CPBPrintingDevice::SetJobSettingL(TInt aCapabilityID, TInt aValue, TInt& aAffectedCapability)

   484 	{

   485 	LOG2("CPBPrintingDevice::SetJobSettingL begin, aCapabilityID %d aValue %d", aCapabilityID, aValue);

   486 

   487 	aAffectedCapability = aCapabilityID;

   488 	

   489 	RArray<TDpsArgsInt>& config = iStart.iReqParam.iJobConfig;

   490 	TInt err = KErrNone;

   491 	if ( iState != EPBJobReady )

   492 		{

   493 		LOG1("CPBPrintingDevice::SetJobSettingL invalid state %d", iState);

   494 		err = KErrInvalidSequence;

   495 		}

   496 	else if ( aCapabilityID == EPrintCapabPaperSize )

   497 		{

   498 		TInt* dpsValue = iCapToDps.Find( aValue );

   499 		if ( dpsValue )

   500 		    {

   501 			config[EPBSettingPaperSize].iContent = *dpsValue;

   502 		

   503 			// for CertSW: needs layouts for particular paper sizes

   504 			iUserSelectedPaperSize = config[EPBSettingPaperSize].iContent;

   505 		    }

   506 		else

   507 			{

   508 			LOG("CPBPrintingDevice::SetJobSettingL invalid value");

   509 			err = KErrInvalidData;

   510 			}

   511 	    }

   512 	else if ( aCapabilityID == EPrintCapabQuality )

   513 		{

   514 		TInt* dpsValue = iCapToDps.Find( aValue );

   515 		if ( dpsValue )

   516 			{

   517 			config[EPBSettingQuality].iContent = *dpsValue;

   518 			}

   519 		else

   520 			{

   521 			LOG("CPBPrintingDevice::SetJobSettingL invalid value");

   522 			err = KErrInvalidData;

   523 			}

   524 		}

   525 	else if ( aCapabilityID == EPrintCapabLayout )

   526 		{

   527 		TInt* dpsValue = iCapToDps.Find( aValue );

   528 		if ( dpsValue )

   529 			{

   530 			config[EPBSettingLayout].iContent = *dpsValue;

   531 			}

   532 		else

   533 			{

   534 			LOG("CPBPrintingDevice::SetJobSettingL invalid value");

   535 			err = KErrInvalidData;

   536 			}

   537 		}

   538 	else

   539 		{

   540 		LOG("CPBPrintingDevice::SetJobSettingL invalid capabilityID");

   541 		err = KErrArgument;

   542 		}	    

   543 		

   544 	LOG1("CPBPrintingDevice::SetJobSettingL end, return code %d", err);

   545 	return err;	

   546 	}

   547 

   548 

   549 TInt CPBPrintingDevice::GetNumPreviewPages()

   550 	{

   551 	LOG1("CPBPrintingDevice::GetNumPreviewPages ends with: %d", 1);

   552 	return 1;

   553 	}

   554 

   555 TInt CPBPrintingDevice::GetJobTemplateIconL( TInt /*aTemplateID*/, TInt& /*aFsBitmapHandle*/ )

   556 	{

   557 	return KErrNone;

   558 	}

   559 

   560 

   561 TInt CPBPrintingDevice::CreatePreviewImage(TInt /*aPageNumber*/)

   562 	{

   563 	return KErrNotSupported;

   564 	}

   565 

   566 void CPBPrintingDevice::RegisterIdleObserver( MProtIdleObserver *aObserver )

   567 	{

   568 	iIdleObserver = aObserver;

   569 	}

   570 

   571 void CPBPrintingDevice::DoCancel()

   572 	{

   573 	iDpsEngine->CancelDpsRequest();

   574 	if ( iWait.IsStarted() )

   575 		{

   576 		LOG("CPBPritingDevice::DoCancel() calling iWait.AsyncStop()");

   577 		iWait.AsyncStop();

   578 		}	

   579 	}

   580 

   581 void CPBPrintingDevice::RunL()

   582 	{

   583 	LOG2("CPBPrintingDevice::RunL begin, status %d state %d", iStatus.Int(), iState);

   584 		

   585    	if ( iWait.IsStarted() )

   586     	{

   587     	LOG("CPBPrintingDevice::RunL calling iWait.AsyncStop() and returning");

   588     	iWait.AsyncStop();

   589     	return;

   590     	}

   591     

   592     if ( iStatus.Int() == KErrNone ) // everything ok

   593         {

   594     	switch( iState )

   595     		{

   596     		case EPBDiscovery:

   597     			{    	   			

   598     			iPrinter.iPrinterID = 0;

   599                 iPrinter.iProtocol = KImagePrint_PrinterProtocol_PictBridge;

   600     	        iPrinter.iProperties = 0;

   601 

   602     			if( iConfigS.iResult.iMajorCode == EDpsResultOk ) 

   603     			    {

   604     			    iPrinter.iVendor = TPrinter::EVendorNone;

   605     			

   606     			    HBufC* buf = HBufC::NewLC( iConfigS.iRepParam.iProductName.Length() );

   607     			    TPtr p = buf->Des();

   608     			    p.Copy( iConfigS.iRepParam.iProductName );

   609     			    if ( p.Length() > 84 )

   610     				    {

   611     				    TPtrC p2 = p.Left( 84 );

   612     				    iPrinter.iDisplayName = p2;

   613     				    }

   614     			    else

   615     				    {

   616     				    iPrinter.iDisplayName = p;

   617     				    }

   618     			    

   619     			    CleanupStack::PopAndDestroy( buf );

   620     			    LOG1("CPBPrinterDevice::RunL config displayname %S", &iPrinter.iDisplayName);

   621     			    

   622     			    // Config info have to be saved in file, because it can retrieved only once

   623     			    // when cable is plugged in the device

   624     			    SaveConfigInfoL();

   625     			    }

   626     			

   627                 if( iConfigS.iResult.iMajorCode == EDpsResultNotExecuted )

   628                     {

   629                     // Read info from file

   630                     ReadConfigInfoL();

   631     			    }

   632 

   633     		    iDiscoveryObserver->FoundDeviceL( iPrinter );

   634     		    iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 );

   635     		    iState = EPBReady;

   636 

   637     			// Close Dps request to avoid -14 error

   638     			iDpsEngine->CancelDpsRequest();

   639     		    iDpsEngine->CancelDpsEventNotify();

   640 

   641     			LOG("CPBPrintingDevice::RunL setting state to Ready");

   642     			break;

   643     			}    		

   644     		case EPBSubmittingJob:

   645     			LOG2("CPBPrintingDevice::RunL submittingjob result major 0x%x minor 0x%x", iStart.iResult.iMajorCode, iStart.iResult.iMinorCode);

   646     			if ( iStart.iResult.iMajorCode == EDpsResultOk )

   647     				{

   648     				LOG("CPBPrintingDevice::RunL setting state to Printing");

   649     				iState = EPBPrinting;

   650     				

   651     				// for Cert software remove dialog from UI 

   652     				iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage );

   653     				}

   654     			else

   655     				{

   656     				LOG("CPBPrintingDevice::RunL error occurred, setting state to JobReady");

   657     				iState = EPBJobReady;

   658     				if ( iPrintEventObserver )

   659     					{

   660     					TPrintMessageCodes err = EPbStatusErrorReasonNoReason;

   661     					if ( iStart.iResult.iMajorCode == EDpsResultNotSupported &&

   662     						 iStart.iResult.iMinorCode == EDpsResultMissingParam )

   663     						{

   664     						// image file is probably missing

   665     						err = EPbFileNotFound;

   666     						}						

   667     					iPrintEventObserver->PrinterStatusEvent( err );

   668     					iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling );

   669     					}

   670     				}

   671     			break;    			

   672     		case EPBCancelling:			

   673     			LOG2("CPBPrintingDevice::RunL cancelling result major 0x%x minor 0x%x", iAbort.iResult.iMajorCode, iAbort.iResult.iMinorCode);

   674     			

   675     			if( iAbort.iResult.iMajorCode == EDpsResultNotExecuted )

   676     			    {

   677     			    iCancelRetry++;

   678     			    CancelPrintJob();

   679     			    }

   680     			

   681     			if( iAbort.iResult.iMajorCode == EDpsResultOk )

   682     			    {

   683     			    if ( iPrintEventObserver )

   684     				    {

   685     				    iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling );

   686     				    }

   687 

   688     			        LOG("CPBPrintingDevice::RunL setting state to JobReady");

   689     			        iState = EPBJobReady;

   690     			        iCancelRetry = 0;

   691     			        }

   692     			break;    		

   693     		default:

   694     			LOG1("CPBPrintingDevice::RunL unrecognized state %d", iState);

   695     			break;

   696 		}	

   697     } 

   698 	else // iStatus != KErrNone -> Handle error here 

   699 	    {

   700 	    switch( iStatus.Int()  )

   701     		{

   702     		case KErrTimedOut:

   703     			LOG( "CPBPrintingDevice::RunL KErrTimedOut" );

   704 				if ( iPrintEventObserver )

   705 			        {

   706 				    LOG("CPBPrintingDevice::Timeout, finish printing...");

   707 				    iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling );

   708 				    }

   709     			break;

   710     		default:

   711     		    // Handle error here.

   712     		    LOG2( "CPBPrintingDevice::RunL error, status %d state %d", iStatus.Int(), iState );

   713     		    break;

   714     		}

   715 	    }

   716 	

   717 	LOG("CPBPrintingDevice::RunL end");

   718 	}

   719 

   720 TInt CPBPrintingDevice::RunError( TInt aError )

   721 	{

   722 	LOG1("CPBPrintingDevice::RunError code %d", aError);

   723 	if ( iWait.IsStarted() )

   724 		{		

   725 		LOG("CPBPrintingDevice::RunError calling iWait.AsyncStop()");

   726 		iWait.AsyncStop();

   727 		}

   728 	return KErrNone;

   729 	}

   730 

   731 		

   732 void CPBPrintingDevice::SetNumsOfCopiesL( const RArray<TInt>& aNumsOfCopies, TInt& aErr )

   733 	{

   734 	LOG("CPBPrintingDevice::SetNumsOfCopiesL begin");

   735 		

   736 	if ( iState != EPBJobReady )

   737 		{

   738 		LOG1("CPBPrintingDevice::SetNumsOfCopiesL invalid state %d", iState);

   739 		aErr = KErrInvalidSequence;

   740 		}		

   741 	else if ( aNumsOfCopies.Count() != iStart.iReqParam.iPrintInfo.Count() )

   742 		{

   743 		LOG2("CPBPrintingDevice::SetNumsOfCopiesL counts don't match, %d %d", aNumsOfCopies.Count(), iStart.iReqParam.iPrintInfo.Count());

   744 		aErr = KErrInvalidData;

   745 		}

   746 	else

   747 		{	

   748 		for ( TInt i = 0; i < aNumsOfCopies.Count(); ++i )

   749 			{

   750 			iStart.iReqParam.iPrintInfo[i].iCopies = aNumsOfCopies[i];

   751 			}			

   752 		aErr = KErrNone;

   753 		}

   754 	

   755 	LOG("CPBPrintingDevice::SetNumsOfCopiesL end");

   756 	}

   757 

   758 

   759 void CPBPrintingDevice::ConnectionNotifyL( TInt aStatus )

   760 	{

   761 	LOG2("CPBPrintingDevice::ConnectionNotifyL begin, status %d iState %d", aStatus, iState);

   762     switch ( aStatus )

   763         {        

   764         case CDpsEngine::ENotConnected:

   765         	LOG("CPBPrintingDevice::ConnectionNotify not connected");

   766         	break;

   767         case CDpsEngine::EPrinterConnected:

   768         	LOG("CPBPrintingDevice::ConnectionNotifyL printer connected");

   769         	iPrinterConnected = ETrue;

   770         	iDisconnectPrinter = EFalse;

   771 	        if ( iIdleObserver )

   772 		        {

   773 		        LOG("CPBPrintingDevice::ConnectionNotifyL informing idle observer about connect");

   774 		        TEvent event = { KImagePrint_PrinterProtocol_PictBridge, ENotSpecified, EConnect };

   775 		        iIdleObserver->StatusEvent( event, KErrConnected, ENoMessage );

   776 	    	    }

   777         	break;        

   778         case CDpsEngine::EPrinterDisconnected:

   779 					iPrinterConnected = EFalse;

   780 					iDisconnectPrinter = ETrue;

   781         	if ( iState != EPBUninitialized )

   782 	        	{

   783 	        	Cancel();

   784 	        	if ( iState == EPBDiscovery )

   785 		        	{

   786 		        			//We're not interested if the call back leaves

   787 							TRAP_IGNORE( iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 ) );

   788 		        	}		        	

   789 					LOG("CPBPrintingDevice::ConnectionNotifyL printer disconnected, setting state to Uninitialized");

   790 	        	iState = EPBUninitialized;

   791 	        	}

   792 	        if ( iIdleObserver )

   793 		        {

   794 		        LOG("CPBPrintingDevice::ConnectionNotifyL informing idle observer about disconnect");

   795 		        TEvent event = { KImagePrint_PrinterProtocol_PictBridge, ENotSpecified, EDisconnect };

   796 		        iIdleObserver->StatusEvent( event, KErrDisconnected, ENoMessage );

   797 	    	    }

   798 	        break;	        

   799         case CDpsEngine::EOtherConnected:

   800         	LOG("CPBPrintingDevice::ConnectionNotify other connected");

   801         	break;        

   802         case CDpsEngine::EWrongPrintModeConnected: 

   803             LOG("CPBPrintingDevice::ConnectionNotify Other personality");

   804             iPrinterConnected = ETrue;

   805             iDisconnectPrinter = EFalse;

   806 	        if ( iIdleObserver )

   807 		        {

   808 		        LOG("CPBPrintingDevice::ConnectionNotifyL informing idle observer about connect");

   809 		        TEvent event = { KImagePrint_PrinterProtocol_PictBridge, ENotSpecified, EConnect };

   810 		        iIdleObserver->StatusEvent( event, KErrConnected, ENoMessage );

   811 	    	    }

   812         	break;                        

   813         default:

   814         	LOG1("CPBPrintingDevice::ConnectionNotifyL unrecognized status %d", aStatus);

   815 	        break;

   816         }

   817 	LOG("CPBPrintingDevice::ConnectionNotifyL end");

   818 	}

   819 

   820 void CPBPrintingDevice::JobNotify( const TDpsGetJobStatus& aStatus )

   821 	{		

   822 	LOG1("CPBPrintingDevice::JobNotify begin, state %d", iState);

   823     LOG2("CPBPrintingDevice::JobNotify progress %d, prtPID %d", aStatus.iRepParam.iProgress, aStatus.iRepParam.iPrtPID);

   824     LOG1("CPBPrintingDevice::JobNotify copyID %d", aStatus.iRepParam.iCopyID);

   825     LOG2("CPBPrintingDevice::JobNotify filepath %S, images printed %d", &aStatus.iRepParam.iFilePath, aStatus.iRepParam.iImagesPrinted);        

   826     

   827     if ( iPrintEventObserver )

   828 	    {

   829 	    iPrintEventObserver->PrintJobProgressEvent( EActive, aStatus.iRepParam.iProgress, ENoMessage );

   830 	    }

   831     

   832 	LOG("CPBPrintingDevice::JobNotify end");

   833 	}

   834 

   835 void CPBPrintingDevice::PrinterNotify( const TDpsGetPrinterStatus& aStatus )

   836 	{		

   837 	LOG1("CPBPrintingDevice::PrinterNotify begin, state %d", iState );

   838     LOG2("CPBPrintingDevice::PrinterNotify service status 0x%x, job status 0x%x", aStatus.iRepParam.iPrintStatus, aStatus.iRepParam.iJobStatus);

   839     LOG2("CPBPrintingDevice::PrinterNotify error status 0x%x, job end reason 0x%x", aStatus.iRepParam.iErrorStatus, aStatus.iRepParam.iJobEndReason.iMajor);

   840     LOG1("CPBPrintingDevice::PrinterNotify aStatus.iRepParam.iNewJobOk 0x%x,", aStatus.iRepParam.iNewJobOk);

   841     

   842     // New job checking that job is ok and device status is ok.

   843     iNewJobOK = aStatus.iRepParam.iNewJobOk;

   844     

   845     TPBProtocolState oldState = iState;

   846     if ( iState == EPBPrinting )

   847 		{

   848 		// for SWCert software to indicate that printing state has executed

   849 		iPrintingStateComplete = 1;

   850 		

   851 		if ( aStatus.iRepParam.iJobStatus == EDpsJobStatusEndedOk )

   852 			{

   853 			LOG("CPBPrintingDevice::PrinterNotify job finished successfully, setting state to JobReady");

   854 			if ( iPrintEventObserver )

   855 				{

   856 				LOG("CPBPrintingDevice::PrinterNotify job finished iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage );");

   857 				iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage );

   858 				}

   859 			iState = EPBJobReady;

   860 			}

   861 		else if ( aStatus.iRepParam.iJobStatus != EDpsJobStatusNotEnded )

   862 			{

   863 			LOG("CPBPrintingDevice::PrinterNotify job aborted, setting state to JobReady");

   864 			if ( iPrintEventObserver )

   865 				{

   866 				iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling );

   867 				}

   868 			iState = EPBJobReady;

   869 			}

   870 		}

   871 

   872     if ( iState == EPBJobReady )

   873         { 

   874         // for Cert software: CertSW doesn't give any indication about aStatus.iRepParam.iJobStatus 

   875         // it only indicate printer state. We have to send message to UI to remove generig progress bar.

   876         if ( aStatus.iRepParam.iPrintStatus == EDpsPrintServiceStatusIdle && iPrintingStateComplete )

   877             {

   878 			// for Cert software to indicate that idle state has executed

   879 			iPrintingStateComplete = 0;

   880 			

   881 			if ( iPrintEventObserver )

   882 				{

   883 			    LOG("CPBPrintingDevice::PrinterNotify job finished iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage );");

   884 			    

   885 			    // for Cert software remove dialog from UI 

   886 			    iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage );

   887 				}

   888             }

   889         }

   890 

   891     if ( !iPrintEventObserver )

   892 	    {

   893 	    LOG("CPBPrintingDevice::PrinterNotify no event observer, returning");

   894 	    return;

   895 	    }

   896     

   897 	TPrintMessageCodes err = DpsJobError( aStatus.iRepParam.iJobEndReason );

   898     if ( err == ENoMessage && aStatus.iRepParam.iErrorStatus == EDpsErrorStatusFatal )

   899 		{

   900 		// Show fatal error

   901 		err = EPbStatusErrorReasonHardwareFatal;

   902 		}	        

   903     

   904     if ( err == ENoMessage && aStatus.iRepParam.iErrorStatus == EDpsErrorStatusWarning )

   905 		{

   906 		// Show warning

   907 		err = EPbStatusErrorReasonWarning;

   908 		}	        

   909 

   910     if ( err != ENoMessage )

   911 	    {

   912 	    if ( oldState == EPBPrinting )

   913 		    {

   914 		    LOG1("CPBPrintingDevice::PrinterNotify calling PrintJobErrorEvent with code %d", err);

   915 		    iPrintEventObserver->PrintJobErrorEvent( err );

   916 			}

   917 		else

   918 			{

   919 			LOG1("CPBPrintingDevice::PrinterNotify calling PrinterStatusEvent with code %d", err);

   920 			iPrintEventObserver->PrinterStatusEvent( err );

   921 			}

   922 	    }

   923     				

   924 	LOG("CPBPrintingDevice::PrinterNotify end");

   925 	}

   926 

   927 void CPBPrintingDevice::HandlePapersizesResponseL( TPrintCapability& aCapability )

   928 	{

   929     LOG2("CPBPrintingDevice::HandlePapersizesResponseL result major 0x%x minor 0x%x", iCap.iResult.iMajorCode, iCap.iResult.iMinorCode);

   930 	LOG2("CPBPrintingDevice::HandlePapersizesResponseL cap 0x%x count %d", iCap.iRepParam.iCap, iCap.iRepParam.iContent.Count());	

   931 	

   932 	aCapability.iCapabilityID = EPrintCapabPaperSize;

   933 	aCapability.iType = TPrintCapability::Int;

   934 	aCapability.iDefaultValue = EPrintCapabPaperSizeAuto;

   935 	aCapability.iEnumCount = 0;

   936 	

   937 	if ( iCap.iResult.iMajorCode == EDpsResultOk )

   938 		{		

   939 	    for ( TInt i = 0; i < iCap.iRepParam.iContent.Count() && aCapability.iEnumCount < KMaxEnumAmount; ++i )

   940 	        {

   941 	        LOG1("CPBPrintingDevice::HandlePapersizesResponseL content 0x%x", iCap.iRepParam.iContent[i]);

   942 	        switch ( iCap.iRepParam.iContent[i] )

   943 		        {

   944 		        case EDpsPaperSizeDefault:

   945 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeAuto;

   946 		        	iCapToDps.InsertL( EPrintCapabPaperSizeAuto, EDpsPaperSizeDefault );

   947 		        	break;		        	

   948 	        	case EDpsPaperSizeLetter:

   949 	        		aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeLetter;

   950 	        		iCapToDps.InsertL( EPrintCapabPaperSizeLetter, EDpsPaperSizeLetter );

   951 	        		break;	        		

   952 	        	case EDpsPaperSizeA4:

   953 	        		aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeA4;

   954 	        		iCapToDps.InsertL( EPrintCapabPaperSizeA4, EDpsPaperSizeA4 );

   955 	        		break;	        		

   956 	        	case EDpsPaperSizeA6:

   957 	        		aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeA6;

   958 	        		iCapToDps.InsertL( EPrintCapabPaperSizeA6, EDpsPaperSizeA6 );

   959 	        		break;	        		

   960 	        	case EDpsPaperSize4x6:

   961 	        		aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSize4x6;

   962 	        		iCapToDps.InsertL( EPrintCapabPaperSize4x6, EDpsPaperSize4x6 );

   963 	        		break;

   964 	        	case EDpsPaperSize2L:

   965 	        		aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSize5x7;

   966 	        		iCapToDps.InsertL( EPrintCapabPaperSize5x7, EDpsPaperSize2L );

   967 	        		break;	        			        		

   968 	        	default:

   969 	        		break;

   970 	    	    }

   971 	        }

   972 	    }

   973 	}

   974 

   975 	

   976 void CPBPrintingDevice::HandleQualitiesResponseL( TPrintCapability& aCapability )

   977 	{

   978     LOG2("CPBPrintingDevice::HandleQualitiesResponseL result major 0x%x minor 0x%x", iCap.iResult.iMajorCode, iCap.iResult.iMinorCode);

   979 	LOG2("CPBPrintingDevice::HandleQualitiesResponseL cap 0x%x count %d", iCap.iRepParam.iCap, iCap.iRepParam.iContent.Count());	

   980 	

   981 	aCapability.iCapabilityID = EPrintCapabQuality;

   982 	aCapability.iType = TPrintCapability::Int;

   983 	aCapability.iDefaultValue = EPrintCapabQualityDefault;

   984 	aCapability.iEnumCount = 0;

   985 

   986 	if ( iCap.iResult.iMajorCode == EDpsResultOk )

   987 		{		

   988 	    for ( TInt i = 0; i < iCap.iRepParam.iContent.Count() && aCapability.iEnumCount < KMaxEnumAmount; ++i )

   989 	        {

   990 	        LOG1("CPBPrintingDevice::HandleQualitiesResponseL content 0x%x", iCap.iRepParam.iContent[i]);

   991 	        switch ( iCap.iRepParam.iContent[i] )

   992 		        {

   993 		        case EDpsPrintQualityDefault:

   994 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityDefault;

   995 		        	iCapToDps.InsertL( EPrintCapabQualityDefault, EDpsPrintQualityDefault );

   996 		        	break;

   997 		        case EDpsPrintQualityNormal:

   998 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityNormal;

   999 		        	iCapToDps.InsertL( EPrintCapabQualityNormal, EDpsPrintQualityNormal );

  1000 		        	break;

  1001 		        case EDpsPrintQualityDraft:

  1002 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityDraft;

  1003 		        	iCapToDps.InsertL( EPrintCapabQualityDraft, EDpsPrintQualityDraft );

  1004 		        	break;

  1005 		        case EDpsPrintQualityFine:

  1006 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityFine;

  1007 		        	iCapToDps.InsertL( EPrintCapabQualityFine, EDpsPrintQualityFine );

  1008 		        	break;		        	

  1009 		        default:

  1010 		        	break;

  1011 		        }

  1012 		    }

  1013 		}

  1014 	if ( !aCapability.iEnumCount )

  1015 		{

  1016 		LOG("CPBPrintingDevice::HandleQualitiesResponseL not supported, set to default");

  1017     	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityDefault;

  1018     	iCapToDps.InsertL( EPrintCapabQualityDefault, EDpsPrintQualityDefault );

  1019 		}

  1020 	}

  1021 

  1022 void CPBPrintingDevice::HandleLayoutsResponseL( TPrintCapability& aCapability )

  1023 	{		

  1024     LOG2("CPBPrintingDevice::HandleLayoutsResponseL result major 0x%x minor 0x%x", iCap.iResult.iMajorCode, iCap.iResult.iMinorCode);

  1025 	LOG2("CPBPrintingDevice::HandleLayoutsResponseL cap 0x%x count %d", iCap.iRepParam.iCap, iCap.iRepParam.iContent.Count());

  1026 	

  1027 	aCapability.iCapabilityID = EPrintCapabLayout;

  1028 	aCapability.iType = TPrintCapability::Int;

  1029 	aCapability.iDefaultValue = EPrintCapabLayout1Up;

  1030 	aCapability.iEnumCount = 0;

  1031 

  1032 	if ( iCap.iResult.iMajorCode == EDpsResultOk )

  1033 		{		

  1034 	    for ( TInt i = 0; i < iCap.iRepParam.iContent.Count() && aCapability.iEnumCount < KMaxEnumAmount; ++i )

  1035 	        {

  1036 	        LOG1("CPBPrintingDevice::HandleLayoutsResponseL content 0x%x", iCap.iRepParam.iContent[i]);

  1037 	        switch ( iCap.iRepParam.iContent[i] )

  1038 		        {

  1039 		        case EDpsLayout1Up:

  1040 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout1Up;

  1041 		        	iCapToDps.InsertL( EPrintCapabLayout1Up, EDpsLayout1Up );

  1042 		        	break;		        

  1043 		        case EDpsLayout2Up:

  1044 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout2Up;

  1045 		        	iCapToDps.InsertL( EPrintCapabLayout2Up, EDpsLayout2Up );

  1046 		        	break;		        

  1047 		        case EDpsLayout4Up:

  1048 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout4Up;

  1049 		        	iCapToDps.InsertL( EPrintCapabLayout4Up, EDpsLayout4Up );

  1050 		        	break;		        

  1051 		        case EDpsLayout6Up:

  1052 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout6Up;

  1053 		        	iCapToDps.InsertL( EPrintCapabLayout6Up, EDpsLayout6Up );

  1054 		        	break;		        

  1055 		        case EDpsLayout9Up:

  1056 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout9Up;

  1057 		        	iCapToDps.InsertL( EPrintCapabLayout9Up, EDpsLayout9Up );

  1058 		        	break;		        	

  1059 		        // do not support this EDpsLayoutBorderless, set default value

  1060 		        case EDpsLayoutBorderless:

  1061 		        	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout1UpBorderless;

  1062 		        	iCapToDps.InsertL( EPrintCapabLayout1UpBorderless, EDpsLayoutDefault );

  1063 		        	break;		        		        	

  1064 		        default:

  1065 		        	break;

  1066 		        }			

  1067 		    }

  1068 		}

  1069 	if ( !aCapability.iEnumCount )

  1070 		{

  1071 		LOG("CPBPrintingDevice::HandleLayoutsResponseL not supported, set to default");

  1072     	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout1Up;

  1073     	iCapToDps.InsertL( EPrintCapabLayout1Up, EDpsLayoutDefault );

  1074 		}

  1075 	}

  1076 

  1077 TInt CPBPrintingDevice::GetPapersizeJobSetting( TInt& aValue )

  1078 	{

  1079 	LOG("CPBPrintingDevice::GetPapersizeJobSetting begin");

  1080 

  1081 	TDpsArgsInt& paper = iStart.iReqParam.iJobConfig[EPBSettingPaperSize];

  1082 	switch ( paper.iContent )

  1083 		{

  1084 		case EDpsPaperSizeDefault:

  1085 			aValue = EPrintCapabPaperSizeAuto;

  1086 			return KErrNone;		

  1087     	case EDpsPaperSizeLetter:

  1088 			aValue = EPrintCapabPaperSizeLetter;

  1089 			return KErrNone;    		

  1090     	case EDpsPaperSizeA4:

  1091 			aValue = EPrintCapabPaperSizeA4;

  1092 			return KErrNone;    		

  1093     	case EDpsPaperSizeA6:

  1094 			aValue = EPrintCapabPaperSizeA6;

  1095 			return KErrNone;    		

  1096     	case EDpsPaperSize4x6:

  1097 			aValue = EPrintCapabPaperSize4x6;

  1098 			return KErrNone;			

  1099     	case EDpsPaperSize2L:

  1100     		aValue = EPrintCapabPaperSize5x7;

  1101     		return KErrNone;

  1102 		default:

  1103 			LOG1("CPBPrintingDevice::GetPapersizeJobSetting unknown %x", paper.iContent);

  1104 			break;

  1105 		}				

  1106 

  1107 	LOG("CPBPrintingDevice::GetPapersizeJobSetting end");

  1108 	return KErrInvalidData;

  1109 	}

  1110 

  1111 TInt CPBPrintingDevice::GetQualityJobSetting( TInt& aValue )

  1112 	{

  1113 	LOG("CPBPrintingDevice::GetQualityJobSetting begin");

  1114 

  1115 	TDpsArgsInt& config = iStart.iReqParam.iJobConfig[EPBSettingQuality];

  1116 	switch ( config.iContent )

  1117 		{

  1118         case EDpsPrintQualityDefault:

  1119 			aValue = EPrintCapabQualityDefault;

  1120 			return KErrNone;

  1121         case EDpsPrintQualityNormal:

  1122 			aValue = EPrintCapabQualityNormal;

  1123 			return KErrNone;

  1124         case EDpsPrintQualityDraft:

  1125 			aValue = EPrintCapabQualityDraft;

  1126 			return KErrNone;

  1127         case EDpsPrintQualityFine:

  1128 			aValue = EPrintCapabQualityFine;

  1129 			return KErrNone;			

  1130 		default:

  1131 			LOG1("CPBPrintingDevice::GetQualityJobSetting unknown %x", config.iContent);

  1132 			break;

  1133 		}				

  1134