/*
* 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: Contains the CPrintJob class definition and the PJS enum.
*
*/
#include <e32std.h>
#include <pathinfo.h>
#include <driveinfo.h>
#include "cprintjob.h"
#include "printcapabilitycodes.h"
#include "imageprint.h"
#include "clog.h"
#include "tbtmapper.h"
#include "btprotocolconsts.h"
// Public functions
//--------------------------------------------------------------------------------------------
//
// CPrintJob::NewL
//
//--------------------------------------------------------------------------------------------
CPrintJob* CPrintJob::NewL(CRsBtDevice* aDevice, RArray<TFileName>& aImages,
const TDesC8& aUserName)
{
CPrintJob* self = new (ELeave) CPrintJob(aDevice);
CleanupStack::PushL(self);
self->ConstructL(aImages, aUserName);
CleanupStack::Pop(); // self
return self;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::~CPrintJob
//
//--------------------------------------------------------------------------------------------
CPrintJob::~CPrintJob()
{
iImages.Reset();
iImages.Close();
iDevice = NULL;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::SetJobId
//
//--------------------------------------------------------------------------------------------
void CPrintJob::SetJobId(const TInt aId)
{
iJobId = aId;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetJobId
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::JobId()
{
return iJobId;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetJobName
//
//--------------------------------------------------------------------------------------------
void CPrintJob::GetJobName(TDes8& aJobName)
{
// Return the name of first image
if (iImages.Count() > 0)
{
iImages[0].GetFilePath(aJobName);
}
else
{
aJobName.Append(KNullDesC8());
}
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::ImageCount
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::ImageCount()
{
return iImages.Count();
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::Images
//
//--------------------------------------------------------------------------------------------
void CPrintJob::Images(RArray<CImageInfo>& aImages)
{
for (TInt i=0; i < iImages.Count(); i++)
{
aImages.Append(iImages[i]);
}
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::PrinterId
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::PrinterId()
{
if(Device())
return Device()->DeviceId();
return KErrNotFound;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetUserName
//
//--------------------------------------------------------------------------------------------
void CPrintJob::GetUserName(TPtrC8& aUserName)
{
aUserName.Set(iUserName);
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetUserName
//
//--------------------------------------------------------------------------------------------
CRsBtDevice* CPrintJob::Device()
{
if(iDevice)
return iDevice;
else
return NULL;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::SetNumsOfCopies
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::SetNumsOfCopies( const RArray<TInt>& aNumsOfCopies)
{
TInt err = KErrNone;
for(TInt arrayIx = 0, imgIx = 0; arrayIx < aNumsOfCopies.Count(); ++arrayIx)
{
if(iImages[imgIx].Index() < aNumsOfCopies.Count())
{
TInt copies = aNumsOfCopies[iImages[imgIx].Index()];
if(0 < copies)
iImages[imgIx].SetCopies(copies);
++imgIx;
}
else
err = KErrCorrupt;
}
return err;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetPrintFileL
//
//--------------------------------------------------------------------------------------------
void CPrintJob::GetPrintFileL(TDes8& aPrintFile)
{
LOG("[CPrintJob::GetPrintFileL]\t begin");
TInt layout;
TInt paper;
TInt quality;
GetPrintSetting(EPrintCapabLayout, layout);
GetPrintSetting(EPrintCapabPaperSize, paper);
GetPrintSetting(EPrintCapabQuality, quality);
TFileName tmpFile;
tmpFile.Copy(aPrintFile);
CXhtmlFileComposer* fileComposer = CXhtmlFileComposer::NewLC(KNullDesC());
LOG("[CPrintJob::GetPrintFileL]\t create file");
fileComposer->CreateXhtmlFileL( iImages, layout, paper, quality, tmpFile, iSheets );
CleanupStack::PopAndDestroy(fileComposer);
aPrintFile.Copy(tmpFile);
LOG("[CPrintJob::GetPrintFileL]\t file created");
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::Sheets
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::Sheets()
{
if(0 == iSheets)
{
TInt layout;
TInt layoutNbr = 1;
TInt imageNbr = 0;
// We don't care about return value here: if GetPrintSetting
// fails, we can anyway tell there will be at least an image/page
GetPrintSetting(EPrintCapabLayout, layout);
switch( layout )
{
case EPrintCapabLayout1Up:
case EPrintCapabLayout1UpBorderless:
case EPrintCapabLayout1UpBorder:
layoutNbr = 1;
break;
case EPrintCapabLayout2Up:
layoutNbr = 2;
break;
case EPrintCapabLayout4Up:
layoutNbr = 4;
break;
case EPrintCapabLayout6Up:
layoutNbr = 6;
break;
case EPrintCapabLayout9Up:
layoutNbr = 9;
break;
case EPrintCapabLayout12Up:
layoutNbr = 12;
break;
case EPrintCapabLayout16Up:
layoutNbr = 16;
break;
default:
break;
}
for (TInt i = 0; i<iImages.Count(); ++i)
{
imageNbr += iImages[i].Copies();
}
iSheets = imageNbr / layoutNbr;
if(0 < imageNbr % layoutNbr)
{
++iSheets;
}
}
LOG1("[CPrintJob::Sheets]\t iSheets = %d", iSheets);
return iSheets;
}
// Protected functions
//--------------------------------------------------------------------------------------------
//
// CPrintJob::ConstructL
//
//--------------------------------------------------------------------------------------------
void CPrintJob::ConstructL(RArray<TFileName>& aImages, const TDesC8& aUserName)
{
if (aImages.Count() < 1)
{
User::Leave(KErrArgument);
}
_LIT(KObex, "obex:");
_LIT(KMmc, "\\mmc");
_LIT(KLocal, "\\media");
_LIT(KSlash, "/");
_LIT(KBackSlash, "\\");
// Initialize iImages array
for (TInt i=0 ; i<aImages.Count(); i++)
{
// Skip empty strings
if (aImages[i].Length() < 1)
{
continue;
}
aImages[i].LowerCase();
CImageInfo imageInfo;
imageInfo.SetId(KErrNotFound);
imageInfo.SetIndex(i);
imageInfo.SetCopies(1);
// Image file path
imageInfo.SetFilePathL(aImages[i]);
// Parse obex "uri"
TFileName tmpUri;
TParse parse;
parse.Set(aImages[i], NULL, NULL);
// Get drive id and root path when multiple drive is enabled.
TInt driveId;
TFileName localRoot;
User::LeaveIfError(DriveInfo::GetDefaultDrive(DriveInfo::EDefaultPhoneMemory, driveId));
User::LeaveIfError(PathInfo::GetRootPath(localRoot, driveId));
localRoot.LowerCase();
tmpUri.Copy(KObex());
// Note here: the correct format would be uuid.LongForm(),
// but in currently supported services it is not required.
tmpUri.AppendNum(KBTSDPDPROService, EHex);
TFileName drive = parse.Drive();
TInt pos = localRoot.Find(drive);
if(KErrNotFound < pos)
{
tmpUri.Append(KLocal());
}
else
{
tmpUri.Append(KMmc());
}
tmpUri.Append(parse.Path());
tmpUri.Append(parse.NameAndExt());
pos = tmpUri.Find(KBackSlash());
while(KErrNotFound != pos)
{
tmpUri.Replace(pos, KBackSlash().Length(), KSlash());
pos = tmpUri.Find(KBackSlash());
}
LOG1("[CPrintJob::ConstructL]\t tmpUri: \"%S\"", &tmpUri);
imageInfo.SetUriL(tmpUri);
// LOG82("[CPrintJob::ConstructL]\t iFilePath: \"%S\", iUri: \"%S\"", &imageInfo.iFilePath, &imageInfo.iUri);
iImages.Append(imageInfo);
}
iUserName.Copy(aUserName);
iSheets = 0;
}
// Private functions
//--------------------------------------------------------------------------------------------
//
// CPrintJob::CPrintJob
//
//--------------------------------------------------------------------------------------------
CPrintJob::CPrintJob(CRsBtDevice* aDevice) :
iJobId(KErrNotFound),
iDeviceId(KErrNotFound),
iDevice(aDevice),
iUserName(KNullDesC8()),
iSheets(0),
iJobState(CPrintJob::EStateNone)
{
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::UpdateJobState
//
//--------------------------------------------------------------------------------------------
void CPrintJob::UpdateJobState(const TJobState aState)
{
iJobState = aState;
}
//--------------------------------------------------------------------------------------------
//
// CPrintJob::JobState
//
//--------------------------------------------------------------------------------------------
CPrintJob::TJobState CPrintJob::JobState()
{
return iJobState;
}
//--------------------------------------------------------------------------------------------
// CPrintJob::GetPrintSetting
//--------------------------------------------------------------------------------------------
TInt CPrintJob::GetPrintSetting(TInt aCapabilityID, TInt& aValue)
{
if(Device())
{
for(TInt i = 0; i < Device()->CapabilityCount(); ++i)
{
TPrintCapability c;
if(KErrNone == Device()->GetCapability(aCapabilityID, c) )
{
aValue = c.iDefaultValue;
LOG2("[CPrintJob::GetPrintSetting]\t %d = %d", aCapabilityID, aValue);
return KErrNone;
}
}
}
aValue = KErrNotFound;
LOG("[CPrintJob::GetPrintSetting]\t out: KErrInvalidData");
return KErrInvalidData;
}
//--------------------------------------------------------------------------------------------
// CPrintJob::SetPrintSetting
//--------------------------------------------------------------------------------------------
TInt CPrintJob::SetPrintSetting(TInt aCapabilityID, TInt aValue)
{
LOG2("[CPrintJob::SetPrintSetting]\t %d = %d", aCapabilityID, aValue);
if(Device())
return Device()->SetDefaultCapability(aCapabilityID, aValue);
LOG("[CPrintJob::GetPrintSetting]\t out: KErrInvalidData");
return KErrInvalidSequence;
}
// End of File