// EIKPRTDG.CPP
//
// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
//
																	    
#include <prnsetup.h>
#include <txtrich.h>
#include <flddef.h>
#include <bamdesca.h>
#include <barsread.h>
#include <gdi.h>
#include <eikprtdg.h>
#include <eikenv.h>
#include <eikchlst.h>
#include <eikfpne.h>
#include <eikhopbt.h>
#include <eiklabel.h>
#include <eikprogi.h>
#include <eikrted.h>
#include <eikmnbut.h>
#include <eikbtpan.h>
#include <eikchkbx.h>
#include <eikcfdlg.h>
#include <eikdlgtb.h>
#include <eiklbbut.h>
#include <eikpriv.hrh>
#include <eikedwin.hrh>
#include <eikdialg.hrh>
#include <eikcmds.hrh>
#include <eikpanic.h>
#include <eikmenup.h>
#include <eiktxtut.h>
#include <eikpgsel.h>
#include <eikon.rsg>

const TUid KUidPrinterPortFlag={268435728};
const TUid KUidSerialPortConfig={268435729};
const TUid KUidFilePortConfig={268435730};

const TInt KEikAlertMaxMsgLength=80;

const TInt EGranularity=4;

//
// class CEikPageSpecDialog
//
		   
const TInt KTwipsEdTolerance=8;				   


EXPORT_C CEikPageSetupDialog::CEikPageSetupDialog(CPrintSetup* aPrintSetup)
     
	:iPrintSetup(aPrintSetup),
	iPageSpecInTwips(iPrintSetup->PrinterDevice()->CurrentPageSpecInTwips()),
	iPageMarginsInTwips(iPrintSetup->iPageMarginsInTwips.iMargins)
	{}

void CEikPageSetupDialog::PreLayoutDynInitL()
	{
	//size
	TInt buttonId=EEikCidPageSpecPortrait;
	TSize displaySizeInTwips=iPageSpecInTwips.iPortraitPageSize;
	if (iPageSpecInTwips.iOrientation)
		{
		buttonId=EEikCidPageSpecLandscape;
		displaySizeInTwips.iWidth=iPageSpecInTwips.iPortraitPageSize.iHeight;
		displaySizeInTwips.iHeight=iPageSpecInTwips.iPortraitPageSize.iWidth;
		}
	((CEikHorOptionButtonList*)Control(EEikCidPageSpecOrientation))->SetButtonById(buttonId);
	
	SetTwipsEditorValueL(EEikCidPageSpecWidth,&displaySizeInTwips.iWidth);
	SetTwipsEditorValueL(EEikCidPageSpecHeight,&displaySizeInTwips.iHeight);

	TInt pageSizeNameIndex=FindPageSizeNameIndex(iPageSpecInTwips.iPortraitPageSize);
	SetChoiceListCurrentItem(EEikCidPageSpecSizeName,pageSizeNameIndex);
   //margins
												 
	SetTwipsEditorValueL(EEikCidPageMarginLeft,&iPageMarginsInTwips.iLeft);
	SetTwipsEditorValueL(EEikCidPageMarginRight,&iPageMarginsInTwips.iRight);
	SetTwipsEditorValueL(EEikCidPageMarginTop,&iPageMarginsInTwips.iTop);
	SetTwipsEditorValueL(EEikCidPageMarginBottom,&iPageMarginsInTwips.iBottom);
	
	//header/footer
	if (!iPrintSetup->Header()->Text())
		iPrintSetup->Header()->CreateTextL();
	if (!iPrintSetup->Footer()->Text())
		iPrintSetup->Footer()->CreateTextL();
	AdjustAllIdsOnPage(EEikPidFooter,EEikCidPageFooterTxt-EEikCidPageHeaderTxt);

	CEikDialogToolBar* headerBar=(CEikDialogToolBar*)Control(EEikCidHeaderRTxtTBar);
	CEikDialogToolBar* footerBar=(CEikDialogToolBar*)Control(EEikCidFooterRTxtTBar);
	CEikRichTextEditor* header=(CEikRichTextEditor*)Control(EEikCidPageHeaderTxt);
	CEikRichTextEditor* footer=(CEikRichTextEditor*)Control(EEikCidPageFooterTxt);

	header->SetButtonGroup(headerBar);
	footer->SetButtonGroup(footerBar);
	header->CreateScrollBarFrameL();
	header->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EAuto, CEikScrollBarFrame::EAuto);
	footer->CreateScrollBarFrameL();
	footer->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EAuto, CEikScrollBarFrame::EAuto);
	header->SetGraphicsDevice(iPrintSetup->PrinterDevice());	
	footer->SetGraphicsDevice(iPrintSetup->PrinterDevice());	

	header->SetDocumentContentL(*(iPrintSetup->Header()->Text()));
	footer->SetDocumentContentL(*(iPrintSetup->Footer()->Text()));
	header->RichText()->UpdateAllFieldsL();
	footer->RichText()->UpdateAllFieldsL();
	//offset				
	SetControlCaptionL(EEikCidFooterMargin,R_EIK_TBUF_FOOTER_MARGIN_CAPTION);
	SetTwipsEditorValueL(EEikCidHeaderMargin,&iPrintSetup->iPageMarginsInTwips.iHeaderOffset);
	SetTwipsEditorValueL(EEikCidFooterMargin,&iPrintSetup->iPageMarginsInTwips.iFooterOffset);
	//page numbering
	SetNumberEditorValue(EEikCidNumOfFirstPage,iPrintSetup->iNumOfFirstPage);

	CEikButtonBase::TState set=(iPrintSetup->Header()->FirstPageToPrintTo()==0)? CEikButtonBase::ESet : CEikButtonBase::EClear;
	SetCheckBoxState(EEikCidIncludeHeaderOnFPage,set);

	set=(iPrintSetup->Footer()->FirstPageToPrintTo()==0)? CEikButtonBase::ESet : CEikButtonBase::EClear;
	SetCheckBoxState(EEikCidIncludeFooterOnFPage,set);
	}															

TBool CEikPageSetupDialog::OkToExitL(TInt /*aButtonId*/)
    {
	TSize displaySizeInTwips;  

	displaySizeInTwips.iWidth=TwipsEditorValue(EEikCidPageSpecWidth);
	displaySizeInTwips.iHeight=TwipsEditorValue(EEikCidPageSpecHeight);
	//margins
	iPageMarginsInTwips.iLeft=TwipsEditorValue(EEikCidPageMarginLeft);
	iPageMarginsInTwips.iRight=TwipsEditorValue(EEikCidPageMarginRight);
	
	if (iPageMarginsInTwips.iLeft+iPageMarginsInTwips.iRight>=displaySizeInTwips.iWidth)
		// this can be handled by HandleControlEvent function. 
		//The infomessage should display min and max values for margins.
		iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_TOTAL_MARGINS_INVALID);    
		  
	iPageMarginsInTwips.iTop=TwipsEditorValue(EEikCidPageMarginTop);
	iPageMarginsInTwips.iBottom=TwipsEditorValue(EEikCidPageMarginBottom);

	if (iPageMarginsInTwips.iTop+iPageMarginsInTwips.iBottom>=displaySizeInTwips.iHeight)
		iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_TOTAL_MARGINS_INVALID);    

	TPageMargins margins;
	margins.iHeaderOffset=TwipsEditorValue(EEikCidHeaderMargin);
	margins.iFooterOffset=TwipsEditorValue(EEikCidFooterMargin);
	TBool equaltozero=(iPageMarginsInTwips.iTop==0 && margins.iHeaderOffset==0);
	if (iPageMarginsInTwips.iTop<=margins.iHeaderOffset && ! equaltozero)
			iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_TOTAL_HEADER_FOOTER_MARGINS_INVALID);    
	
	equaltozero=(iPageMarginsInTwips.iBottom==0 &&margins.iFooterOffset==0);
	if (iPageMarginsInTwips.iBottom<=margins.iFooterOffset && !equaltozero)
			iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_TOTAL_HEADER_FOOTER_MARGINS_INVALID);    
	
	TInt buttonId;
	buttonId=((CEikHorOptionButtonList*)Control(EEikCidPageSpecOrientation))->LabeledButtonId();
	iPageSpecInTwips.iOrientation=(buttonId==EEikCidPageSpecLandscape? TPageSpec::ELandscape : TPageSpec::EPortrait);


	iPageSpecInTwips.iPortraitPageSize=displaySizeInTwips;

	if (iPageSpecInTwips.iOrientation)
		{
		iPageSpecInTwips.iPortraitPageSize.iWidth=displaySizeInTwips.iHeight;
		iPageSpecInTwips.iPortraitPageSize.iHeight=displaySizeInTwips.iWidth;
		}

	//header/footer
	CEikRichTextEditor* header=(CEikRichTextEditor*)Control(EEikCidPageHeaderTxt);
	delete iPrintSetup->Header()->Text();
	delete iPrintSetup->Header()->ParaFormat();
	delete iPrintSetup->Header()->CharFormat();
	CRichText* text=header->RichText();
	header->SetDocumentOwnership(CEikEdwin::EDoesNotOwnText);
	iPrintSetup->Header()->SetText(text);
	iPrintSetup->Header()->SetParaFormat(CONST_CAST(CParaFormatLayer*,text->GlobalParaFormatLayer()));
	iPrintSetup->Header()->SetCharFormat(CONST_CAST(CCharFormatLayer*,text->GlobalCharFormatLayer()));
	
	CEikRichTextEditor* footer=(CEikRichTextEditor*)Control(EEikCidPageFooterTxt);
	delete iPrintSetup->Footer()->Text();
	delete iPrintSetup->Footer()->ParaFormat();
	delete iPrintSetup->Footer()->CharFormat();
	text=footer->RichText();
	footer->SetDocumentOwnership(CEikEdwin::EDoesNotOwnText);
	iPrintSetup->Footer()->SetText(text);
	iPrintSetup->Footer()->SetParaFormat(CONST_CAST(CParaFormatLayer*,text->GlobalParaFormatLayer()));
	iPrintSetup->Footer()->SetCharFormat(CONST_CAST(CCharFormatLayer*,text->GlobalCharFormatLayer()));
	
	iPrintSetup->PrinterDevice()->SelectPageSpecInTwips(iPageSpecInTwips);
	iPrintSetup->iPageMarginsInTwips.iMargins=iPageMarginsInTwips;
	iPrintSetup->iPageMarginsInTwips.iHeaderOffset=margins.iHeaderOffset;
	iPrintSetup->iPageMarginsInTwips.iFooterOffset=margins.iFooterOffset;
	//numbering
	iPrintSetup->iNumOfFirstPage=NumberEditorValue(EEikCidNumOfFirstPage);
	CEikButtonBase::TState include=CheckBoxState(EEikCidIncludeHeaderOnFPage);
	TInt page=!include;
	iPrintSetup->Header()->SetFirstPageToPrintTo(page);
	include=CheckBoxState(EEikCidIncludeFooterOnFPage);
	page=!include;
	iPrintSetup->Footer()->SetFirstPageToPrintTo(page);

    return(ETrue);													
    }


void CEikPageSetupDialog::HandleControlStateChangeL(TInt aControlId)  
	{
	switch (aControlId)
		{
	case EEikCidPageSpecSizeName:
	case EEikCidPageSpecOrientation:
		{
		TSize displaySizeInTwips;
		TBool swapWidthAndHeight=EFalse;
		if (aControlId==EEikCidPageSpecSizeName)
			{
			TInt pageSizeNameIndex=ChoiceListCurrentItem(EEikCidPageSpecSizeName);
			displaySizeInTwips=FindPageSizeInPortraitFormat(pageSizeNameIndex);
			TInt buttonId;
			buttonId=((CEikHorOptionButtonList*)Control(EEikCidPageSpecOrientation))->LabeledButtonId();
			if (buttonId==EEikCidPageSpecLandscape)
				swapWidthAndHeight=ETrue;
			}
		else
			{
			displaySizeInTwips.iWidth=TwipsEditorValue(EEikCidPageSpecWidth);
			displaySizeInTwips.iHeight=TwipsEditorValue(EEikCidPageSpecHeight);
			swapWidthAndHeight=ETrue;
			}
		if (swapWidthAndHeight)
			{
			TInt oldWidth=displaySizeInTwips.iWidth;
			displaySizeInTwips.iWidth=displaySizeInTwips.iHeight;
			displaySizeInTwips.iHeight=oldWidth;
			}
		SetTwipsEditorValueL(EEikCidPageSpecWidth,&displaySizeInTwips.iWidth);
		SetTwipsEditorValueL(EEikCidPageSpecHeight,&displaySizeInTwips.iHeight);
		break;
		}
	case EEikCidPageSpecWidth:
	case EEikCidPageSpecHeight:
		{ // The size has been altered
		TSize size;
		TInt customIndex=FindPageSizeNameIndex(size);
		SetChoiceListCurrentItem(EEikCidPageSpecSizeName,customIndex);
		iSizeChanged=ETrue;
		break;
		}
	case EEikCidHeaderRTxtTBar:
	case EEikCidFooterRTxtTBar:
		{
		const TInt ctrlId=STATIC_CAST(CEikDialogToolBar*,Control(aControlId))->StateChangeControlId();
		const TInt control=(PageSelector()->CurrentPageControlId()==EEikPidFooter)? EEikCidPageFooterTxt : EEikCidPageHeaderTxt;
		switch (ctrlId)
			{
		case EEikCidPageSetupFormat:
			{
			TInt tBarId=(control==EEikCidPageHeaderTxt)? EEikCidHeaderRTxtTBar:EEikCidFooterRTxtTBar;
			CEikDialogToolBar* tBar=(CEikDialogToolBar*)Control(tBarId);
			CEikLabeledButton* button=STATIC_CAST(CEikLabeledButton*,tBar->ControlById(EEikCidPageSetupFormat));
			STATIC_CAST(CEikMenuButton*,button->Button())->LaunchPopupMenuL(this);
			break;
			}
		case EEikCidPageSetupInsert:
			{
			TInt tBarId=(control==EEikCidPageHeaderTxt)? EEikCidHeaderRTxtTBar:EEikCidFooterRTxtTBar;
			CEikDialogToolBar* tBar=(CEikDialogToolBar*)Control(tBarId);
			CEikLabeledButton* button=STATIC_CAST(CEikLabeledButton*,tBar->ControlById(EEikCidPageSetupInsert));
			STATIC_CAST(CEikMenuButton*,button->Button())->LaunchPopupMenuL(this);
			break;
			}
		case EEikCidFontDialog:
			{
			CEikRichTextEditor* ed=(CEikRichTextEditor*)Control(control);
			ed->RunFontDialogL(EEikNoSymbolFonts,iPrintSetup->PrinterDevice());
			ed->UpdateButtonGroup();
			break;
			}
		case EEikCidFontBoldBut:
			STATIC_CAST(CEikRichTextEditor*,Control(control))->BoldItalicUnderlineEventL(CEikGlobalTextEditor::EBold);
			break;
		case EEikCidFontItalicBut:
			STATIC_CAST(CEikRichTextEditor*,Control(control))->BoldItalicUnderlineEventL(CEikGlobalTextEditor::EItalic);
			break;
		case EEikCidFontUnderlineBut:
			STATIC_CAST(CEikRichTextEditor*,Control(control))->BoldItalicUnderlineEventL(CEikGlobalTextEditor::EUnderline);
			break;
		default:
			;
			}
		}
	default:
		;
		}
	}


void CEikPageSetupDialog::ValidateFocusControlL()
    {
	if (!iSizeChanged)
		return;// No need to check as only the change of custom size needs to find out the pageSizeNameIndex
	TSize displaySizeInTwips;  

	displaySizeInTwips.iHeight=TwipsEditorValue(EEikCidPageSpecHeight);
	displaySizeInTwips.iWidth=TwipsEditorValue(EEikCidPageSpecWidth);

	TInt buttonId=((CEikHorOptionButtonList*)Control(EEikCidPageSpecOrientation))->LabeledButtonId();
	if (buttonId==EEikCidPageSpecLandscape)
		{
		if (displaySizeInTwips.iHeight>displaySizeInTwips.iWidth)
			{
			displaySizeInTwips.iWidth=TwipsEditorValue(EEikCidPageSpecWidth);
			displaySizeInTwips.iHeight=TwipsEditorValue(EEikCidPageSpecHeight);
	
			SetTwipsEditorValueL(EEikCidPageSpecWidth,&displaySizeInTwips.iHeight);
			SetTwipsEditorValueL(EEikCidPageSpecHeight,&displaySizeInTwips.iWidth);
			}
		else
			{
			TInt oldWidth=displaySizeInTwips.iWidth;
			displaySizeInTwips.iWidth=displaySizeInTwips.iHeight;
			displaySizeInTwips.iHeight=oldWidth;
			}
		}
	else
		{
		if (displaySizeInTwips.iWidth>displaySizeInTwips.iHeight)
			{
			TInt oldWidth=displaySizeInTwips.iWidth;
			displaySizeInTwips.iWidth=displaySizeInTwips.iHeight;
			displaySizeInTwips.iHeight=oldWidth;

			SetTwipsEditorValueL(EEikCidPageSpecHeight,&displaySizeInTwips.iHeight);
			SetTwipsEditorValueL(EEikCidPageSpecWidth,&displaySizeInTwips.iWidth);
			}
		}
	
	TInt pageSizeNameIndex=FindPageSizeNameIndex(displaySizeInTwips);
	SetChoiceListCurrentItem(EEikCidPageSpecSizeName,pageSizeNameIndex);
	iSizeChanged=EFalse;
    }

TInt CEikPageSetupDialog::FindPageSizeNameIndex(const TSize aSize)
    {	  // aSize must be in Portrait format!!
	if (aSize==KA4PaperSizeInTwips)
		return 0;
	if (aSize==KLegalPaperSizeInTwips)
		return 2;
	if (aSize==KExecutivePaperSizeInTwips)
		return 3;
	if (aSize==KLetterPaperSizeInTwips)
		return 4;
	if (aSize==KCom_10PaperSizeInTwips)
		return 5;
	if (aSize==KMonarchPaperSizeInTwips)
		return 6;
	if (aSize==KDLPaperSizeInTwips)
		return 7;
	if (aSize==KC5PaperSizeInTwips)
		return 8;
	else
		return 1;
	}

TSize CEikPageSetupDialog::FindPageSizeInPortraitFormat(TInt aPageSizeNameIndex)
    {
	TSize size=iPrintSetup->PrinterDevice()->CurrentPageSpecInTwips().iPortraitPageSize; 
	if (aPageSizeNameIndex==0)
		return KA4PaperSizeInTwips;
	if (aPageSizeNameIndex==2)
		return KLegalPaperSizeInTwips ;
	if (aPageSizeNameIndex==3)
		return KExecutivePaperSizeInTwips;
	if (aPageSizeNameIndex==4)
		return KLetterPaperSizeInTwips;
	if (aPageSizeNameIndex==5)
		return KCom_10PaperSizeInTwips;
	if (aPageSizeNameIndex==6)
		return KMonarchPaperSizeInTwips;
	if (aPageSizeNameIndex==7)
		return KDLPaperSizeInTwips;
	if (aPageSizeNameIndex==8)
		return KC5PaperSizeInTwips;
	else
		return size;
    }

void CEikPageSetupDialog::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane)
	{
	 if (aResourceId==R_EIK_FIELD_MENU)	//there is only one menu
		 {
		 if (!iPrintSetup->Header()->FileNameFieldInfo()) //if header file/page field is set than it is assumed that footer is set as well
			aMenuPane->SetItemDimmed(EEikCmdFieldFileName,ETrue);
		 if (!iPrintSetup->Header()->NumPagesFieldInfo())
			aMenuPane->SetItemDimmed(EEikCmdFieldNumberOfPages,ETrue);
		 }
	 if (aResourceId==R_EIK_FORMAT_MENU) // for time being
		 {
		 const TInt control=(PageSelector()->CurrentPageControlId()==EEikPidFooter)? EEikCidPageFooterTxt : EEikCidPageHeaderTxt;
		 CEikRichTextEditor* ed=(CEikRichTextEditor*)Control(control);
		 TInt count=ed->RichText()->ComponentInfo().iPictureCount;
		 if (!count)
			aMenuPane->SetItemDimmed(EEikCmdFormatObject,ETrue);
		 }
	}

void CEikPageSetupDialog::ProcessCommandL(TInt aCommand)
	{
	const TInt control=(PageSelector()->CurrentPageControlId()==EEikPidFooter)? EEikCidPageFooterTxt : EEikCidPageHeaderTxt;
	CEikRichTextEditor* ed=(CEikRichTextEditor*)Control(control);
	switch (aCommand)
		{
	case EEikCmdFieldFileName:
		{
		CFileNameField* fNameField=new(ELeave) CFileNameField;
		if (control==EEikCidPageHeaderTxt)
			fNameField->SetFileNameInfo(iPrintSetup->Header()->FileNameFieldInfo());
		else
			fNameField->SetFileNameInfo(iPrintSetup->Footer()->FileNameFieldInfo());
		ed->InsertFieldL(fNameField,KFileNameFieldUid);
		break;
		}
	case EEikCmdFieldPageNumber: 
		{
		CTextField* pNumberField=ed->RichText()->NewTextFieldL(KPageNumberFieldUid);
		ed->InsertFieldL(pNumberField,KPageNumberFieldUid);  
		break;	
		}
	case EEikCmdFieldNumberOfPages: 
		{
		CNumPagesField* numPageField=new(ELeave) CNumPagesField;
		if (control==EEikCidPageHeaderTxt)
			numPageField->SetNumPagesInfo(iPrintSetup->Header()->NumPagesFieldInfo());
		else
			numPageField->SetNumPagesInfo(iPrintSetup->Footer()->NumPagesFieldInfo());
		ed->InsertFieldL(numPageField,KNumPagesFieldUid);  
		break;	
		}
	case EEikCmdFieldInsertObject:
		ed->InsertObjectL(CEikRichTextEditor::EGlassIfPossible);
		break;
	case EEikCmdFieldCurrentTime:
	case EEikCmdFieldCurrentDate:
		{
		CTextField* dateTimeField=ed->RichText()->NewTextFieldL(KDateTimeFieldUid);
		if (aCommand==EEikCmdFieldCurrentDate)
			((CDateTimeField*)dateTimeField)->SetFormat((_L("%D%M%Y%/0%1%/1%2%/2%3%/3")));
		else
			((CDateTimeField*)dateTimeField)->SetFormat((_L("%*J%:1%T%B")));
		ed->InsertFieldL(dateTimeField,KDateTimeFieldUid);  
		break;
		}
	case EEikCmdFormatObject:
		ed->EditPictureFormatL();
		break;
	case EEikCmdParaTabs:
		{ 
		TInt width=TwipsEditorValue(EEikCidPageSpecWidth);
		TInt leftmargin=TwipsEditorValue(EEikCidPageMarginLeft);
		TInt rightmargin=TwipsEditorValue(EEikCidPageMarginRight);
		width-=(leftmargin+rightmargin);
		ed->RunTabsDialogL(width);
		break;
		}
	case EEikCmdParaBorder:
	case EEikCmdParaAlign:
		ed->RunParaDialogsL(aCommand);
		break;
		}	  
	}

void CEikPageSetupDialog::SetEmphasis(CCoeControl* /*aMenuControl*/,TBool /*aEmphasis*/)
	{
	}


//										 
// Class CEikPrinterSetupDialog
//

EXPORT_C CEikPrinterSetupDialog::CEikPrinterSetupDialog(CPrintSetup* aPrintSetup,TUid& aUid)
	:iUid(aUid)
	{
	iPrintSetup=aPrintSetup;
    }

EXPORT_C CEikPrinterSetupDialog::~CEikPrinterSetupDialog()
	{
	delete iArray;
	if (iPrinterDriverUi)
		delete iPrinterDriverUi;
	delete iTempPrintSetup;
	}

void CEikPrinterSetupDialog::PreLayoutDynInitL()
    {
	// create temp printsetup;

	iTempPrintSetup=CPrintSetup::NewL();
	TBuf<256> dir;
	iEikonEnv->ReadResource(dir,R_EIK_TBUF_PRINTER_DIR);
	iTempPrintSetup->AddPrinterDriverDirL(dir); 
	iTempPrintSetup->CreatePrinterDeviceL(iUid,iEikonEnv->FsSession());
	TPageSpec spec=iPrintSetup->PrinterDevice()->CurrentPageSpecInTwips();
  	iTempPrintSetup->PrinterDevice()->SelectPageSpecInTwips(spec);

	iArray=new(ELeave) CDesCArrayFlat(EGranularity);
	CPrinterModelList* model=iPrintSetup->ModelNameListL(iEikonEnv->FsSession());
	CEikonEnv::GetPrinterNamesL(model,*iArray);
	CEikChoiceList* list = (CEikChoiceList*) Control(EEikCidPrintPrinterModels);
	list->SetArrayL(iArray);
	TInt modelIndex=iPrintSetup->ModelNameListL(iEikonEnv->FsSession())->UidToNum(iUid);
	list->SetCurrentItem(modelIndex);
	//read portflag from ini fle
	TEikPortFlag flag;
	CDictionaryStore* iniFile=CDictionaryFileStore::SystemLC(iEikonEnv->FsSession());
	if (iniFile->IsPresentL(KUidPrinterPortFlag))
		{
		RDictionaryReadStream stream;
		stream.OpenLC(*iniFile,KUidPrinterPortFlag);
		stream>> flag;
		CleanupStack::PopAndDestroy(); // stream
		}
	else
		flag = EFilePort;
	CleanupStack::PopAndDestroy(); //iniFile
	TInt index=0;
	switch (flag)
		{
	case EFilePort:
		index=3; //should be according to the resource file
		break;
	case ESerialPort:
		index=0;
		break;
	case EParallelPort:
		index=1;
		break;
	case EIrdaPort:
		index=2;
		break;
		}
	SetChoiceListCurrentItem(EEikCidPrinterPort,index);
	DisplayDevicePropertiesButtonL();
	UpdatePortControlL();
    }

void CEikPrinterSetupDialog::DisplayDevicePropertiesButtonL()
	{
	TInt index=ChoiceListCurrentItem(EEikCidPrintPrinterModels);
	CPrinterModelList* modelList=iPrintSetup->ModelNameListL(iEikonEnv->FsSession());
	const TPrinterModelEntry model=(*modelList)[index];
	TBool visible=EFalse;
	if (iPrinterDriverUi)
		{
		delete iPrinterDriverUi;
		iPrinterDriverUi=NULL;
		}
	iTempPrintSetup->CreatePrinterDeviceL(model.iUid,iEikonEnv->FsSession());
	iPrintSetup->FreeModelList();
	TRAPD(ret,iPrinterDriverUi=iTempPrintSetup->CreatePrinterDriverUIL());
	if (ret==KErrNone && iPrinterDriverUi)
		{//display the button for setting the properties
		if (iPrinterDriverUi->CanSetProperties())
			visible=ETrue;
		}
	ButtonPanel()->LabeledButtonById(EEikBidPrinterProperties)->MakeVisible(visible);
	ButtonPanel()->LabeledButtonById(EEikBidPrinterProperties)->DrawNow();
	}
																	    
void  CEikPrinterSetupDialog::UpdatePortControlL()
	{
	TInt index=ChoiceListCurrentItem(EEikCidPrintPrinterModels);
	CPrinterModelList* modelList=iPrintSetup->ModelNameListL(iEikonEnv->FsSession());

	const TPrinterModelEntry model=(*modelList)[index];
	TBool visible=model.iRequiresPrinterPort;
	MakeWholeLineVisible(EEikCidPrinterPort,visible);
	TInt pos=ChoiceListCurrentItem(EEikCidPrinterPort);
	if (visible && (pos==1 || pos==2))
		visible=EFalse;
	ButtonPanel()->LabeledButtonById(EEikBidPortSetup)->MakeVisible(visible);
	ButtonPanel()->LabeledButtonById(EEikBidPortSetup)->DrawNow();	 
	}

TBool CEikPrinterSetupDialog::OkToExitL(TInt aButtonId)
    {
	if (aButtonId==EEikBidPrinterProperties && iPrinterDriverUi)
		{
		iPrinterDriverUi->SetPropertiesL();
		if (iUid==iTempPrintSetup->PrinterDevice()->Model().iUid)
			iPrintSetup->PrinterDevice()->RestorePropertiesL();
		return EFalse;
		}
	const TInt pos=ChoiceListCurrentItem(EEikCidPrinterPort);
    if (aButtonId==EEikBidOk)
		{
		TInt index=ChoiceListCurrentItem(EEikCidPrintPrinterModels);
		CPrinterModelList* modelList=iPrintSetup->ModelNameListL(iEikonEnv->FsSession());
  		const TPrinterModelEntry model=(*modelList)[index];
		iUid=model.iUid;  //callers responsibility to check the uid's and set it to new device
		iPrintSetup->FreeModelList();
		//save the portflag to the ini file
		TEikPortFlag flag=EFilePort;
		switch (pos)
			{
		case 0:
			flag=ESerialPort;
			break;
		case 1:
			flag=EParallelPort;
			break;
		case 2:
			flag=EIrdaPort;
			break;
		case 3:
			flag=EFilePort;
			break;
			}
		CDictionaryStore* iniFile=CDictionaryFileStore::SystemLC(iEikonEnv->FsSession());
		RDictionaryWriteStream stream;
		stream.AssignLC(*iniFile,KUidPrinterPortFlag);
		stream<< flag;
		stream.CommitL();
		CleanupStack::PopAndDestroy(); // stream
		iniFile->CommitL();
		CleanupStack::PopAndDestroy(); // iniFile
		return ETrue;
		}
	if (aButtonId==EEikBidPortSetup)
		{
		if (pos==3)
			RunFileDialogL();
		else if (pos==0)
			RunSerialPortDialog();
		return EFalse;
		}
	return(ETrue);
	}

void CEikPrinterSetupDialog::HandleControlStateChangeL(TInt aControlId)
	{
	if (aControlId==EEikCidPrintPrinterModels)
		DisplayDevicePropertiesButtonL();
	UpdatePortControlL();
	}

void CEikPrinterSetupDialog::RunFileDialogL()
	{
	CDictionaryStore* iniFile=CDictionaryFileStore::SystemLC(iEikonEnv->FsSession());
	TFileName fileName;
	if (iniFile->IsPresentL(KUidFilePortConfig))
		{
		RDictionaryReadStream stream;
		stream.OpenLC(*iniFile,KUidFilePortConfig);
		stream>> fileName;
		CleanupStack::PopAndDestroy(); // stream
		}
	else
		iCoeEnv->ReadResource(fileName,R_EIK_TBUF_TEMP_PRN);
	CleanupStack::PopAndDestroy(); // iniFile
	CEikDialog* dialog=new(ELeave) CEikFileSaveAsDialog(&fileName,NULL,R_EIK_TBUF_CREATE_PRINT_TO_FILE);
	if (dialog->ExecuteLD(R_EIK_DIALOG_FILE_SAVEAS))
		{
		iniFile=CDictionaryFileStore::SystemLC(iEikonEnv->FsSession());
		RDictionaryWriteStream stream;
		stream.AssignLC(*iniFile,KUidFilePortConfig);
		stream<< fileName;
		stream.CommitL();
		CleanupStack::PopAndDestroy(); // stream
		iniFile->CommitL();
		CleanupStack::PopAndDestroy(); // iniFile
		}
	}

void CEikPrinterSetupDialog::RunSerialPortDialog()
	{
	CEikDialog* dialog=new(ELeave) CEikSerialPortDialog();
	dialog->ExecuteLD(R_EIK_DIALOG_SERIAL_PORT);
	}


//
// Class CEikPrintProgressDialog
//

EXPORT_C CEikPrintProgressDialog::CEikPrintProgressDialog(CPrintSetup* aPrintSetup, MPageRegionPrinter* aPageRegionPrinter,const TPrintParameters& aPrintParameters)
    {
	iPrintSetup=aPrintSetup;
	iPageRegionPrinter=aPageRegionPrinter;
	iPrintParameters=aPrintParameters;
    }

EXPORT_C CEikPrintProgressDialog::~CEikPrintProgressDialog()
	{
	}
														  
	  
void CEikPrintProgressDialog::PreLayoutDynInitL()
    {
	TBuf<16> mode;
	CPrinterPort* port;
	port=NULL;
	TEikPortFlag flag=EFilePort;
	CDictionaryStore* iniFile=CDictionaryFileStore::SystemLC(iEikonEnv->FsSession());
	if (iniFile->IsPresentL(KUidPrinterPortFlag))
		{
		RDictionaryReadStream stream;
		stream.OpenLC(*iniFile,KUidPrinterPortFlag);
		stream>> flag;
		CleanupStack::PopAndDestroy(); // stream
		}
	//read port flag fom ini file
	switch (flag)
		{
	case ESerialPort:
		{//read serialport config from ini file
		TSerialPrinterPortConfig config;
		if (iniFile->IsPresentL(KUidSerialPortConfig))
			{
			RDictionaryReadStream stream;
			stream.OpenLC(*iniFile,KUidSerialPortConfig);
			stream>> config;
			CleanupStack::PopAndDestroy(); // stream
			}
		iCoeEnv->ReadResource(mode, R_EIK_TBUF_SERIAL);
		if (iPrintSetup->PrinterDevice()->Model().iRequiresPrinterPort)
			{
			iPortFlag=ESerialPort;
			TRAPD(ret,port=CSerialPrinterPort::NewL(_L("COMM::0"),config));
			if (ret!=KErrNone)
				{
				TBuf<80> printingError;
				DisplayErrorMessage(ret,printingError);
				iCoeEnv->LeaveWithErrorText(printingError);
				}
			}
		break;
		}
	case EParallelPort:
		if (iPrintSetup->PrinterDevice()->Model().iRequiresPrinterPort)
			{
			iPortFlag=EParallelPort;
			TRAPD(ret,port=CParallelPrinterPort::NewL(_L("COMM::0")));
			if (ret!=KErrNone)
				{
				TBuf<80> printingError; 
				DisplayErrorMessage(ret,printingError);
				iCoeEnv->LeaveWithErrorText(printingError);
				}
			}
		iCoeEnv->ReadResource(mode, R_EIK_TBUF_PARALLEL);
		break;
	case EIrdaPort:
		if (iPrintSetup->PrinterDevice()->Model().iRequiresPrinterPort)
			{
			iPortFlag=EIrdaPort;
			TRAPD(ret,port=CIrdaPrinterPort::NewL());
			if (ret!=KErrNone)
				{
				TBuf<80> printingError; 
				DisplayErrorMessage(ret,printingError);
				iCoeEnv->LeaveWithErrorText(printingError);
				}
			}
		iCoeEnv->ReadResource(mode, R_EIK_TBUF_IRDA);
		break;
	case EFilePort:	//read filename path from the ini file
		{
		TFileName filename;
		if (iniFile->IsPresentL(KUidFilePortConfig))
			{
			RDictionaryReadStream stream;
			stream.OpenLC(*iniFile,KUidFilePortConfig);
			stream>> filename;
			CleanupStack::PopAndDestroy(); // stream
			}
		else
			iCoeEnv->ReadResource(filename,R_EIK_TBUF_TEMP_PRN);
		if (iPrintSetup->PrinterDevice()->Model().iRequiresPrinterPort)
			{
			iPortFlag=EFilePort;
			TRAPD(ret,port=CFilePrinterPort::NewL(filename))
			if (ret!=KErrNone)
				{
				TBuf<80> printingError; 
				DisplayErrorMessage(ret,printingError);
				iCoeEnv->LeaveWithErrorText(printingError);
				}
			}
		iCoeEnv->ReadResource(mode, R_EIK_TBUF_FILE);
		break;
		}
		}
 	CleanupStack::PopAndDestroy(); //iniFile

	TRAPD(ret,iPrintSetup->StartPrintL(iPrintParameters,*iPageRegionPrinter,port,this));
	if (ret!=KErrNone)
		{
		iPrintSetup->EndPrint();
		TBuf<80> printingError;
		DisplayErrorMessage(ret,printingError);
		iCoeEnv->LeaveWithErrorText(printingError);
		}
	TBuf<256> text;
	TBuf<128> print;
	TPrinterModelName name=iPrintSetup->PrinterDevice()->Model().iModelName;
    if (iPrintSetup->PrinterDevice()->Model().iRequiresPrinterPort)
		{
		iCoeEnv->ReadResource(print, R_EIK_TBUF_PRINTING_TO_VIA);
		text.Format(print, &name, &mode);
		}
    else
		{
	   	iCoeEnv->ReadResource(print, R_EIK_TBUF_PRINTING_TO);
		text.Format(print, &name);		
		}
	SetLabelL(EEikCidPrinterNameWithPort,text);
    }

void CEikPrintProgressDialog::DisplayErrorMessage(TInt aErrCode,TDes& aDes)
	{
	switch (aErrCode)
		{
	case KErrNotReady:
		if (!iPortFlag)//winprint
			iCoeEnv->ReadResource(aDes,R_EIK_TBUF_PRINTING_ERROR_NOT_READY);
		else if (iPortFlag==EFilePort)
			iCoeEnv->ReadResource(aDes,R_EIK_TBUF_DISK_NOT_PRESENT);
		break;
	case KErrCouldNotConnect:
		iCoeEnv->ReadResource(aDes,R_EIK_TBUF_PRINTING_ERROR_COULDNOTCONNECT);
		break;
	case KErrAccessDenied:
		iCoeEnv->ReadResource(aDes,R_EIK_TBUF_PRINTING_ERROR_ACCESSDENIED);
		break;
	case KErrTimedOut:
		iCoeEnv->ReadResource(aDes,R_EIK_TBUF_PRINTING_ERROR_TIMEDOUT);
		break;
	case KErrNoMemory:
		iCoeEnv->ReadResource(aDes,R_EIK_TBUF_NOT_ENOUGH_MEMORY);
		break;
	case KErrNotSupported:
		if (iPrintSetup->PrinterDevice()->CurrentPageSpecInTwips().iOrientation==TPageSpec::ELandscape)
			{
			iCoeEnv->ReadResource(aDes,R_EIK_TBUF_LANDSCAPE_PRINTING_NOT_SUPPORTED);
			break;
			}
	default:
		iCoeEnv->ReadResource(aDes,R_EIK_TBUF_PRINTING_ERROR);
		break;				
		}
	}

TBool CEikPrintProgressDialog::OkToExitL(TInt /*aButtonId*/)
    {
	iPrintSetup->EndPrint();
    return(ETrue);
	}
	
void CEikPrintProgressDialog::NotifyPrintStarted(TPrintParameters /*aPrintParams*/)
	{
	}

void CEikPrintProgressDialog::NotifyPrintEnded(TInt anErrorCode)
    {
	if (anErrorCode==KErrCancel)
		return;
	if (anErrorCode==KErrAbort && iPortFlag==EFilePort)
		{
		delete this;
		return;
		}
	if (anErrorCode!=KErrNone)
		{
		TBuf<80> printingError;
		DisplayErrorMessage(anErrorCode,printingError);
		iEikonEnv->AlertWin(printingError);
		}
	delete (this);
	}

void CEikPrintProgressDialog::NotifyBandPrinted(TInt aPercentageOfPagePrinted, TInt aCurrentPageNum, TInt aCurrentCopyNum)
    {
	CEikProgressInfo* progInfo = (CEikProgressInfo*) Control(EEikCidPrintProgressBar);
	const TInt currentValue=aPercentageOfPagePrinted + (aCurrentPageNum-iPrintParameters.iFirstPage)*100 +
						(aCurrentCopyNum-1)*(iPrintParameters.iLastPage-iPrintParameters.iFirstPage+1)*100;
	const TInt value=(currentValue/(iPrintParameters.iNumCopies*(iPrintParameters.iLastPage-iPrintParameters.iFirstPage+1)));
	progInfo->SetAndDraw(value/progInfo->Info().iFinalValue);
	} 

//
// Class CEikPaginateDialog
//

EXPORT_C CEikPaginateDialog::CEikPaginateDialog(CTextPaginator* aPaginator)
    {
	iPaginator=aPaginator;
    }

void CEikPaginateDialog::PreLayoutDynInitL()
    {
	__ASSERT_DEBUG(iPaginator,Panic(EEikPanicNullPointer));
	iPaginator->SetObserver(this);

	TBuf<8> buf=_L("00000000");
	CEikLabel* label=((CEikLabel*)Control(EEikCidPaginate));
	label->SetTextL(buf);
	label->iAlignment=EHCenterVCenter;
	}

void CEikPaginateDialog::PostLayoutDynInitL()
	{
	TBuf<8> buf;
	TInt pageNumber=1;
	buf.Num(pageNumber);
	iPaginator->PaginateCompleteDocumentL();
	SetLabelL(EEikCidPaginate,buf);
	}

TBool CEikPaginateDialog::OkToExitL(TInt /*aButtonId*/)
    {
	iPaginator->Cancel();
    return(ETrue);
	}

void CEikPaginateDialog::NotifyCompletion()
    {
	TryExitL(EEikBidOk);// this doesn't leave in this case. 
	}

void CEikPaginateDialog::NotifyError(TInt anErrorCode)
    {
	if (anErrorCode!=KErrCancel)
		{
		TBuf<80> paginatingError;
		iCoeEnv->ReadResource(paginatingError,R_EIK_TBUF_PAGINATING_ERROR);
		iEikonEnv->InfoMsg(paginatingError);
		delete(this);
		}
	}

void CEikPaginateDialog::NotifyPageCompletion(TInt aCurrentPageNum)
    {
	TBuf<8> buf;
	buf.Num(aCurrentPageNum+1);
	TRAPD(ret,SetLabelL(EEikCidPaginate,buf));
	}


//
//Serialport settings
//

EXPORT_C CEikSerialPortDialog::CEikSerialPortDialog()
	{
	}

void CEikSerialPortDialog::PostLayoutDynInitL()
	{
	CDictionaryStore* iniFile=CDictionaryFileStore::SystemLC(iEikonEnv->FsSession());
	if (iniFile->IsPresentL(KUidSerialPortConfig))
		{
		RDictionaryReadStream stream;
		stream.OpenLC(*iniFile,KUidSerialPortConfig);
		stream>> iConfig;
		CleanupStack::PopAndDestroy(); // stream
		}
	CleanupStack::PopAndDestroy(); // inifile

	if (iConfig.iHandshake.iXonXoff)
		SetCheckBoxState(EEikCidXonOffTkBx,CEikButtonBase::ESet);
	if (iConfig.iHandshake.iCts)
		SetCheckBoxState(EEikCidRtsCtsTkBx,CEikButtonBase::ESet);
	if (iConfig.iHandshake.iDsr)
		SetCheckBoxState(EEikCidDsrDtrTkBx,CEikButtonBase::ESet);
	if (iConfig.iHandshake.iDcd)
		SetCheckBoxState(EEikCidDcdTkBx,CEikButtonBase::ESet);
	TInt pos=0;
	if (iConfig.iStopBits==EStop2)
		pos=1;
	SetChoiceListCurrentItem(EEikCidSerialStopBits,pos);
	FindIndexFromParity();
	FindIndexFromDataBits();
	FindIndexFromBaudRate();
	}

void CEikSerialPortDialog::FindIndexFromDataBits()
	{
	TInt pos=0;
	switch(iConfig.iDataBits)
		{
	case EData5:
		pos=0;
		break;		
	case EData6:
		pos=1;
		break;
	case EData7:
		pos=2;
		break;
	case EData8:
		pos=3;
		break;
		}
	SetChoiceListCurrentItem(EEikCidSerialDataBits,pos);
	}

void CEikSerialPortDialog::FindDataBitsFromIndex()
	{
	TInt pos=ChoiceListCurrentItem(EEikCidSerialDataBits);
	switch(pos)
		{
	case 0:
		iConfig.iDataBits=EData5;
		break;		
	case 1:
		iConfig.iDataBits=EData6;
		break;
	case 2:
		iConfig.iDataBits=EData7;
		break;
	case 3:
		iConfig.iDataBits=EData8;
		break;
		}
	}

void CEikSerialPortDialog::FindIndexFromParity()
	{
	TInt pos=0;
	switch(iConfig.iParity)
		{
	case EParityNone:
		pos=0;
		break;		
	case EParityEven:
		pos=1;
		break;
	case EParityOdd:
		pos=2;
		break;
	default:
		break;
		}
	SetChoiceListCurrentItem(EEikCidSerialParity,pos);
	}

void CEikSerialPortDialog::FindParityFromIndex()
	{
	TInt pos=ChoiceListCurrentItem(EEikCidSerialParity);
	switch(pos)
		{
	case 0:
		iConfig.iParity=EParityNone;
		break;		
	case 1:
		iConfig.iParity=EParityEven;
		break;
	case 2:
		iConfig.iParity=EParityOdd;
		break;
		}
	}

void CEikSerialPortDialog::FindBaudRateFromIndex()
	{
	TInt pos=ChoiceListCurrentItem(EEikCidSerialBaudRate);
	switch(pos)
		{
	case 0:
		iConfig.iRate=EBps110;
		break;		
	case 1:
		iConfig.iRate=EBps150;
		break;
	case 2:
		iConfig.iRate=EBps300;
		break;
	case 3:
		iConfig.iRate=EBps600;
		break;
	case 4:
		iConfig.iRate=EBps1200;
		break;
	case 5:
		iConfig.iRate=EBps2400;
		break;
	case 6:
		iConfig.iRate=EBps4800;
		break;
	case 7:
		iConfig.iRate=EBps9600;
		break;
	case 8:
		iConfig.iRate=EBps19200;
		break;
	case 9:
		iConfig.iRate=EBps38400;
		break;
	case 10:
		iConfig.iRate=EBps57600;
		break;
	case 11:
		iConfig.iRate=EBps115200;
		break;
		}
	}

void CEikSerialPortDialog::FindIndexFromBaudRate()
	{
	TInt pos=0;
	switch(iConfig.iRate)
		{
	case EBps110:
		pos=0;
		break;
	case EBps150:
		pos=1;
		break;
	case EBps300:
		pos=2;
		break;
	case EBps600:
		pos=3;
		break;
	case EBps1200:
		pos=4;
		break;
	case EBps2400:
		pos=5;
		break;
	case EBps4800:
		pos=6;
		break;
	case EBps9600:
		pos=7;
		break;
	case EBps19200:
		pos=8;
		break;
	case EBps38400:
		pos=9;
		break;
	case EBps57600:
		pos=10;
		break;
	case EBps115200:
		pos=11;
		break;
	default:
		;
		}
	SetChoiceListCurrentItem(EEikCidSerialBaudRate,pos);
	}


TBool CEikSerialPortDialog::OkToExitL(TInt /*aButtonId*/)
	{
	iConfig.iHandshake.iXonXoff=((CEikCheckBox*)Control(EEikCidXonOffTkBx))->State()==CEikButtonBase::ESet? 1 :0;
	iConfig.iHandshake.iCts=((CEikCheckBox*)Control(EEikCidRtsCtsTkBx))->State()==CEikButtonBase::ESet? 1 :0;
	iConfig.iHandshake.iDsr=((CEikCheckBox*)Control(EEikCidDsrDtrTkBx))->State()==CEikButtonBase::ESet? 1 :0;
	iConfig.iHandshake.iDcd=((CEikCheckBox*)Control(EEikCidDcdTkBx))->State()==CEikButtonBase::ESet? 1 :0;
	//stopbits
	TInt pos=ChoiceListCurrentItem(EEikCidSerialStopBits);
	iConfig.iStopBits=(pos==0)? EStop1 : EStop2;
	//parity
	FindParityFromIndex();
	//databits
	FindDataBitsFromIndex();
	//brate
	FindBaudRateFromIndex();

	CDictionaryStore* iniFile=CDictionaryFileStore::SystemLC(iEikonEnv->FsSession());
	RDictionaryWriteStream stream;
	stream.AssignLC(*iniFile,KUidSerialPortConfig);
	stream<< iConfig;
	stream.CommitL();
	CleanupStack::PopAndDestroy(); // stream
	iniFile->CommitL();
	CleanupStack::PopAndDestroy(); // iniFile
	return ETrue;
	}


//
//CEikPrintRangeDialog
//

EXPORT_C CEikPrintRangeDialog::CEikPrintRangeDialog(TPrintParameters& aPrintParameters, CPrintSetup* aPrintSetup,TUid& aUid,TBool aPrintButton)
	:iUid(aUid)
	{
	iPrintParameters=&aPrintParameters;
	iPageRange.iLowerLimit=iPrintParameters->iFirstPage+1;//index starts from 0
	iPageRange.iUpperLimit=iPrintParameters->iLastPage+1;
	iPrintSetup=aPrintSetup;
	iPrintButton=aPrintButton;
	}

EXPORT_C void CEikPrintRangeDialog::PreLayoutDynInitL()
	{
	__ASSERT_DEBUG(iPrintSetup,Panic(EEikPanicNullPointer));
	if (iPrintButton)
		SetTextForOkButtonL();
	SetPrinterNameL();
	SetRangeEditorMinAndMax(EEikCidPrintPageRange,iPageRange.iLowerLimit,iPageRange.iUpperLimit);
	SEikRange initialRange;
	initialRange.iLowerLimit=iPrintParameters->iFirstPage+1;
	initialRange.iUpperLimit=iPrintParameters->iLastPage+1;
	SetRangeEditorValue(EEikCidPrintPageRange,initialRange);
	if (iPageRange.iUpperLimit-iPageRange.iLowerLimit==0)
		{
		DeleteLine(EEikCidPrintPageRange);
		DeleteLine(EEikCidPrintAll);
		}
	else
		{
		SetCheckBoxState(EEikCidPrintAll,CEikButtonBase::ESet);
		SetLineDimmedNow(EEikCidPrintPageRange,ETrue);
		}
	SetNumberEditorValue(EEikCidPrintNoOfCopies,iPrintParameters->iNumCopies);
	}

EXPORT_C TBool CEikPrintRangeDialog::OkToExitL(TInt aButtonId)
	{
	if (aButtonId==EEikBidPrinterSetup)
		{
		TUid id=iUid;
		CEikDialog* dialog=new(ELeave) CEikPrinterSetupDialog(iPrintSetup,iUid);
		if (dialog->ExecuteLD(R_EIK_DIALOG_PRINTER_SETUP))
			{
			if (id!=iUid)
				SetPrinterNameL();		
			}
		return EFalse;
		}
	iPrintParameters->iNumCopies=NumberEditorValue(EEikCidPrintNoOfCopies);
	if (iPageRange.iUpperLimit-iPageRange.iLowerLimit)
		{
		SEikRange chosenRange;
		if (CheckBoxState(EEikCidPrintAll)==CEikButtonBase::ESet)
			chosenRange=iPageRange;
		else
			chosenRange=RangeEditorValue(EEikCidPrintPageRange);
		iPrintParameters->iFirstPage=chosenRange.iLowerLimit-1;
		iPrintParameters->iLastPage=chosenRange.iUpperLimit-1;
		}
	return ETrue;
	}

EXPORT_C void CEikPrintRangeDialog::HandleControlStateChangeL(TInt aControlId)
	{
	if (aControlId==EEikCidPrintAll)  
		{
		TBool dimmed=EFalse;
		if (CheckBoxState(EEikCidPrintAll)==CEikButtonBase::ESet)
			dimmed=ETrue;
		SetLineDimmedNow(EEikCidPrintPageRange,dimmed);
		Control(EEikCidPrintPageRange)->DrawNow();
		}
	}

EXPORT_C void CEikPrintRangeDialog::SetPrinterNameL()
	{
	TBuf<256> text;
	TBuf<128> print;
    iCoeEnv->ReadResource(print, R_EIK_TBUF_PRINT_TO);
	CPrinterModelList* modelList=iPrintSetup->ModelNameListL(iEikonEnv->FsSession());
	TInt index=modelList->UidToNum(iUid);
	if(index<0)
		User::Leave(KErrUnknown);

	const TPrinterModelEntry model=(*modelList)[index];

	TPrinterModelName name=model.iModelName;
	iPrintSetup->FreeModelList();
	if (name.Length()>17)
		TextUtils::TruncateToNumChars(name,16);
    text.Format(print, &name);
	SetLabelL(EEikCidPrinterName,text);
	Control(EEikCidPrinterName)->DrawNow();;
	}

EXPORT_C void CEikPrintRangeDialog::SetTextForOkButtonL()
	{
	TBuf<32> buf;
	iCoeEnv->ReadResource(buf,R_EIK_TBUF_PRINT);
	//set text for button and title
	SetTitleL(R_EIK_TBUF_PRINT);
	CCoeControl* ok=ButtonPanel()->ButtonById(EEikBidOk);
	((CEikCommandButton*)ok)->SetTextL(buf);
	((CEikCommandButton*)ok)->DrawNow();
	}