diff -r 000000000000 -r 1fb32624e06b fontservices/fontstore/src/linkedfonts.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/fontstore/src/linkedfonts.cpp	Tue Feb 02 02:02:46 2010 +0200
@@ -0,0 +1,695 @@
+/*
+* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+#include <s32file.h>
+#include <graphics/shapeimpl.h>
+#include "FNTSTORE.H"
+#include "OPENFONT.H"
+#include "FNTBODY.H"
+#include "FNTSTD.H"
+#include <graphics/shaperparams.h>
+#include "linkedfonts.h"
+#include "linkedfontsprivate.h"
+#include "openfontsprivate.h"
+#include "fbs.h"
+#include <openfontlinkedtypefaceelementspec.h>
+#include <graphics/openfontlinkedtypefacespecification.h>
+
+EXPORT_C CLinkedTypefaceSpecification* CLinkedTypefaceSpecification::NewLC(const TDesC& aTypefaceName)
+	{
+	CLinkedTypefaceSpecification* self = new (ELeave) CLinkedTypefaceSpecification();
+	CleanupStack::PushL(self);
+	self->ConstructL(aTypefaceName);
+	return self;
+	}
+
+CLinkedTypefaceSpecification::CLinkedTypefaceSpecification()
+	{
+	}
+
+void CLinkedTypefaceSpecification::ConstructL(const TDesC &aTypefaceName)
+	{
+	iBody = new (ELeave) CLinkedTypefaceSpecificationBody();
+
+	TInt length = aTypefaceName.Length();
+	if ((length > KMaxTypefaceNameLength) || (length == 0))
+		User::Leave(KErrArgument);
+
+	iBody->iLinkedTypefaceName = aTypefaceName.AllocL();
+	}
+
+EXPORT_C void CLinkedTypefaceSpecification::AddTypefaceAtIndexL(CLinkedTypefaceElementSpec& aElementSpec, TInt aIndex)
+	{
+	DoAddTypefaceL(aElementSpec, aIndex);
+	}
+
+EXPORT_C void CLinkedTypefaceSpecification::AddTypefaceAtBackL(CLinkedTypefaceElementSpec& aElementSpec)
+	{
+	DoAddTypefaceL(aElementSpec, iBody->iTypefaces.Count());
+	}
+
+EXPORT_C TInt CLinkedTypefaceSpecification::RemoveTypeface(TInt aIndex)
+	{
+	if  ( (aIndex < iBody->iTypefaces.Count()) && (aIndex >= 0) )
+		{
+		CLinkedTypefaceElementSpec* elementSpec = iBody->iTypefaces[aIndex];
+		iBody->iTypefaces.Remove(aIndex);
+		delete elementSpec;
+		return KErrNone;
+		}
+	else
+		return KErrNotFound;
+	}
+
+EXPORT_C void CLinkedTypefaceSpecification::RegisterLinkedTypefaceL(CFbsTypefaceStore& aStore)
+	{
+	//Leave if there is no canonical element, or there are multiples.
+	//The remaining validation must be performed in fntstore.
+	User::LeaveIfError(CanonicalIndex());
+	User::LeaveIfError(aStore.RegisterLinkedTypeface(*this));
+	}
+
+EXPORT_C void CLinkedTypefaceSpecification::FetchLinkedTypefaceSpecificationL(CFbsTypefaceStore& aStore)
+	{	
+	aStore.GetLinkedTypefaceL(*this);
+	}
+
+EXPORT_C TInt CLinkedTypefaceSpecification::TypefaceCount() const
+	{
+	return iBody->iTypefaces.Count();
+	}
+
+EXPORT_C TPtrC CLinkedTypefaceSpecification::Name() const
+	{
+	return *iBody->iLinkedTypefaceName;
+	}
+
+EXPORT_C CLinkedTypefaceSpecification::~CLinkedTypefaceSpecification()
+	{
+	delete iBody;
+	}
+
+EXPORT_C TInt CLinkedTypefaceSpecification::CanonicalIndex()
+	{
+	TInt index = KErrNotFound;
+	for (TInt i = iBody->iTypefaces.Count()-1 ; i >= 0; i--)
+		{
+		if (iBody->iTypefaces[i]->Canonical())
+			{
+			if (index == KErrNotFound)
+				index = i;
+			else 
+				return KErrOverflow;
+			}
+		}
+	return index;
+	}
+
+EXPORT_C CLinkedTypefaceElementSpec* CLinkedTypefaceSpecification::Typeface(TInt aIndex) const
+	{
+	if ((aIndex >= iBody->iTypefaces.Count()) || (aIndex < 0))
+		{
+		return NULL;
+		}
+	else
+		{
+		return iBody->iTypefaces[aIndex];
+		}
+	}
+
+void CLinkedTypefaceSpecification::DoAddTypefaceL(CLinkedTypefaceElementSpec& aElementSpec, TInt aPos)
+	{
+	if (iBody->iTypefaces.Count() == KMaxLinkedTypefaces)
+		User::Leave(KErrOverflow);
+	
+	TInt err = iBody->iTypefaces.Find(&aElementSpec);
+
+	if (err != KErrNotFound)
+		User::Leave(KErrAlreadyExists);
+	
+	if (aElementSpec.Canonical() && CanonicalIndex() != KErrNotFound)
+		User::Leave(KErrArgument);
+
+	if (GroupById(aElementSpec.GroupId()) == NULL)
+		User::Leave(KErrArgument);
+	
+	TInt canIndex = CanonicalIndex();
+	if (aElementSpec.Canonical())
+		{
+		if (canIndex!=KErrNotFound)
+			User::Leave(KErrArgument);
+		}
+	
+	err = iBody->iTypefaces.Insert(&aElementSpec, aPos);
+
+	User::LeaveIfError(err);
+	}
+
+EXPORT_C void CLinkedTypefaceSpecification::AddLinkedTypefaceGroupL(CLinkedTypefaceGroup& aGroup)
+	{
+	if (iBody->iGroups.Count() == KMaxLinkedTypefaceGroups)
+		User::Leave(KErrOverflow);
+	
+	for (TInt i = iBody->iGroups.Count()-1 ; i >= 0 ; i--)
+		{
+		if (iBody->iGroups[i]->GroupId() == aGroup.GroupId())
+			User::Leave(KErrAlreadyExists);
+		}
+	iBody->iGroups.AppendL(&aGroup);
+	}
+
+EXPORT_C TInt CLinkedTypefaceSpecification::RemoveLinkedTypefaceGroup(TInt aGroupId)
+	{
+	//Search for & remove the group if it exists
+	CLinkedTypefaceGroup* remove = GroupById(aGroupId);
+	//If the group has been found & removed remove all associated typefaces
+	if (remove)
+		{
+		CLinkedTypefaceElementSpec* elementSpec;
+		for (TInt i = iBody->iTypefaces.Count()-1 ; i >= 0 ; i--)
+			{
+			elementSpec = iBody->iTypefaces[i];
+			if (elementSpec->GroupId() == aGroupId)
+				RemoveTypeface(i);
+			}
+		iBody->iGroups.Remove(iBody->iGroups.Find(remove));
+		delete remove;
+		return KErrNone;
+		}
+	return KErrNotFound;
+	}
+
+EXPORT_C CLinkedTypefaceGroup* CLinkedTypefaceSpecification::GroupById(TInt aGroupId) const
+	{
+	TInt index;
+	TBool found = EFalse;
+	for (index = iBody->iGroups.Count()-1; index != -1 ; index--)
+		{
+		if (iBody->iGroups[index]->GroupId() == aGroupId)
+			{
+			found = ETrue;
+			break;
+			}
+		}
+	
+	if (found)
+		return iBody->iGroups[index];
+	else
+		return NULL;
+	}
+
+EXPORT_C CLinkedTypefaceGroup* CLinkedTypefaceSpecification::Group(TInt aGroupIndex) const
+	{
+	if ( (aGroupIndex >= 0) && (aGroupIndex < iBody->iGroups.Count()) )
+		return iBody->iGroups[aGroupIndex];
+	else
+		return NULL;
+	}
+
+EXPORT_C TInt CLinkedTypefaceSpecification::GroupCount() const
+	{
+	return iBody->iGroups.Count();
+	}
+
+EXPORT_C void CLinkedTypefaceSpecification::Clear()
+	{
+	iBody->iGroups.ResetAndDestroy();
+	iBody->iTypefaces.ResetAndDestroy();
+	}
+
+EXPORT_C void CLinkedTypefaceSpecification::UpdateLinkedTypefaceL(CFbsTypefaceStore& aStore)
+	{
+	User::LeaveIfError(aStore.UpdateLinkedTypeface(*this));
+	}
+
+CLinkedTypefaceSpecificationBody::CLinkedTypefaceSpecificationBody()
+	{
+	}
+
+CLinkedTypefaceSpecificationBody::~CLinkedTypefaceSpecificationBody()
+	{
+	delete iLinkedTypefaceName;
+	iTypefaces.ResetAndDestroy();
+	iGroups.ResetAndDestroy();
+	}
+
+EXPORT_C CLinkedTypefaceElementSpec* CLinkedTypefaceElementSpec::NewLC(const TDesC& aElementName, TInt aGroupId)
+	{
+	CLinkedTypefaceElementSpec* self = new(ELeave)CLinkedTypefaceElementSpec(aGroupId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aElementName);
+	return self;
+	}
+
+EXPORT_C CLinkedTypefaceElementSpec::~CLinkedTypefaceElementSpec()
+	{
+	delete iElementName;
+	}
+
+EXPORT_C TPtrC CLinkedTypefaceElementSpec::ElementName() const
+	{
+	return *iElementName;
+	}
+
+EXPORT_C void CLinkedTypefaceElementSpec::SetCanonical(TBool aIsCanonical)
+	{
+	iIsCanonical = aIsCanonical;
+	}
+
+EXPORT_C TBool CLinkedTypefaceElementSpec::Canonical() const
+	{
+	return iIsCanonical;
+	}
+
+CLinkedTypefaceElementSpec::CLinkedTypefaceElementSpec(TInt aGroupId)
+	{
+	iGroupId = aGroupId;
+	iIsCanonical = EFalse;
+	}
+
+EXPORT_C TInt CLinkedTypefaceElementSpec::GroupId() const
+	{
+	return iGroupId;
+	}
+
+EXPORT_C COpenFontLinkedTypefaceSpecification* COpenFontLinkedTypefaceSpecification::NewLC(const TDesC& aTypefaceName)
+	{
+	COpenFontLinkedTypefaceSpecification* self = new (ELeave) COpenFontLinkedTypefaceSpecification();
+	CleanupStack::PushL(self);
+	self->ConstructL(aTypefaceName);
+	return self;
+	}
+
+EXPORT_C COpenFontLinkedTypefaceSpecification* COpenFontLinkedTypefaceSpecification::NewLC(const TLinkedTypefaceSpecificationArgs& aSpecArgs)
+	{
+	COpenFontLinkedTypefaceSpecification* self = new (ELeave) COpenFontLinkedTypefaceSpecification();
+	CleanupStack::PushL(self);
+	self->ConstructL(aSpecArgs);
+	return self;
+	}
+
+COpenFontLinkedTypefaceSpecification::COpenFontLinkedTypefaceSpecification()
+	{
+	}
+
+void COpenFontLinkedTypefaceSpecification::ConstructL(const TDesC &aTypefaceName)
+	{
+	TInt length = aTypefaceName.Length();
+	if ((length > KMaxTypefaceNameLength) || (length == 0))
+		User::Leave(KErrArgument);
+
+	iLinkedTypefaceName = aTypefaceName.AllocL();
+	}
+
+void COpenFontLinkedTypefaceSpecification::ConstructL(const TLinkedTypefaceSpecificationArgs& aSpecArgs)
+	{
+	iLinkedTypefaceName = aSpecArgs.iName.AllocL();
+
+	TInt i;
+	
+	for (i = 0; i != aSpecArgs.iGroupSize ; i++)
+		{
+		CLinkedTypefaceGroup* grp = CLinkedTypefaceGroup::NewLC(aSpecArgs.iGroups[i].iGroupId);
+		grp->SetBaselineShift(aSpecArgs.iGroups[i].iBaselineShift);
+		grp->SetBoldnessPercentage(aSpecArgs.iGroups[i].iBoldnessPercentage);
+		grp->SetItalicAngle(aSpecArgs.iGroups[i].iItalicAngle);
+		grp->SetScalingOption(aSpecArgs.iGroups[i].iScalingOption);
+		AddLinkedTypefaceGroupL(*grp);
+		CleanupStack::Pop(grp);
+		}
+	
+	for (i = 0 ; i != aSpecArgs.iSize ; i++)
+		{
+		COpenFontLinkedTypefaceElementSpec* es = COpenFontLinkedTypefaceElementSpec::NewLC(aSpecArgs.iTypefaces[i].iName, aSpecArgs.iTypefaces[i].iGroupId);
+		es->SetCanonical(aSpecArgs.iTypefaces[i].iIsCanonical);
+		AddTypefaceAtBackL(*es);
+		CleanupStack::Pop(es);
+		}
+	
+	//ASSERT Can. Indexs match.
+	}
+
+EXPORT_C COpenFontLinkedTypefaceSpecification::~COpenFontLinkedTypefaceSpecification()
+	{
+	delete iLinkedTypefaceName;
+	iTypefaces.ResetAndDestroy();
+	iTypefaces.Close();
+	iGroups.ResetAndDestroy();
+	iGroups.Close();
+	}
+
+EXPORT_C void COpenFontLinkedTypefaceSpecification::AddTypefaceAtIndexL(COpenFontLinkedTypefaceElementSpec& aElementSpec, TInt aIndex)
+	{
+	DoAddTypefaceL(aElementSpec, aIndex);
+	}
+
+EXPORT_C void COpenFontLinkedTypefaceSpecification::AddTypefaceAtBackL(COpenFontLinkedTypefaceElementSpec& aElementSpec)
+	{
+	DoAddTypefaceL(aElementSpec, iTypefaces.Count());
+	}
+
+EXPORT_C TInt COpenFontLinkedTypefaceSpecification::RemoveTypeface(TInt aIndex)
+	{
+	if  ( (aIndex < iTypefaces.Count()) && (aIndex >= 0) )
+		{
+		COpenFontLinkedTypefaceElementSpec* elementSpec = iTypefaces[aIndex];
+		iTypefaces.Remove(aIndex);
+
+		delete elementSpec;
+		return KErrNone;
+		}
+	else
+		return KErrNotFound;
+	}
+
+EXPORT_C TInt COpenFontLinkedTypefaceSpecification::TypefaceCount() const
+	{
+	return iTypefaces.Count();
+	}
+
+EXPORT_C TPtrC COpenFontLinkedTypefaceSpecification::Name() const
+	{
+	return *iLinkedTypefaceName;
+	}
+
+EXPORT_C TInt COpenFontLinkedTypefaceSpecification::CanonicalIndex() const
+	{
+	TInt index = KErrNotFound;
+	for (TInt i = iTypefaces.Count()-1 ; i >= 0; i--)
+		{
+		if (iTypefaces[i]->Canonical())
+			{
+			if (index == KErrNotFound)
+				index = i;
+			else 
+				return KErrOverflow;
+			}
+		}
+	return index;
+	}
+
+EXPORT_C COpenFontLinkedTypefaceElementSpec* COpenFontLinkedTypefaceSpecification::Typeface(TInt aIndex) const
+	{
+	if ((aIndex >= iTypefaces.Count()) || (aIndex < 0))
+		{
+		return NULL;
+		}
+	else
+		{
+		return iTypefaces[aIndex];
+		}
+	}
+
+void COpenFontLinkedTypefaceSpecification::DoAddTypefaceL(COpenFontLinkedTypefaceElementSpec& aElementSpec, TInt aPos)
+	{
+	if (iTypefaces.Count() == KMaxLinkedTypefaces)
+		User::Leave(KErrOverflow);
+	
+	TInt err = iTypefaces.Find(&aElementSpec);
+
+	if (err != KErrNotFound)
+		User::Leave(KErrAlreadyExists);
+	
+	if (aElementSpec.Canonical() && CanonicalIndex() >= 0)
+		User::Leave(KErrArgument);
+	
+	if (GroupById(aElementSpec.GroupId()) == NULL)
+		User::Leave(KErrArgument);
+	
+	err = iTypefaces.Insert(&aElementSpec, aPos);
+
+	User::LeaveIfError(err);
+	}
+
+EXPORT_C void COpenFontLinkedTypefaceSpecification::AddLinkedTypefaceGroupL(CLinkedTypefaceGroup& aGroup)
+	{
+	if (iGroups.Count() == KMaxLinkedTypefaceGroups)
+		User::Leave(KErrOverflow);
+	
+	for (TInt i = iGroups.Count()-1 ; i >= 0 ; i--)
+		{
+		if (iGroups[i]->GroupId() == aGroup.GroupId())
+			User::Leave(KErrAlreadyExists);
+		}
+	iGroups.AppendL(&aGroup);
+	}
+
+EXPORT_C TInt COpenFontLinkedTypefaceSpecification::RemoveLinkedTypefaceGroup(TInt aGroupId)
+	{
+	//Search for & remove the group if it exists
+	CLinkedTypefaceGroup* remove = GroupById(aGroupId);
+	//If the group has been found & removed remove all associated typefaces
+	if (remove)
+		{
+		COpenFontLinkedTypefaceElementSpec* elementSpec;
+		for (TInt i = iTypefaces.Count()-1 ; i >= 0 ; i--)
+			{
+			elementSpec = iTypefaces[i];
+			if (elementSpec->GroupId() == aGroupId)
+				RemoveTypeface(i);
+			}
+		iGroups.Remove(iGroups.Find(remove));
+		delete remove;
+		return KErrNone;
+		}
+	return KErrNotFound;
+	}
+
+EXPORT_C CLinkedTypefaceGroup* COpenFontLinkedTypefaceSpecification::GroupById(TInt aGroupId) const
+	{
+	TInt index;
+	TBool found = EFalse;
+	for (index = iGroups.Count()-1; index != -1 ; index--)
+		{
+		if (iGroups[index]->GroupId() == aGroupId)
+			{
+			found = ETrue;
+			break;
+			}
+		}
+	
+	if (found)
+		return iGroups[index];
+	else
+		return NULL;
+	}
+
+EXPORT_C const CLinkedTypefaceGroup* COpenFontLinkedTypefaceSpecification::Group(TInt aGroupIndex) const
+	{
+	if ( (aGroupIndex >= 0) && (aGroupIndex < iGroups.Count()) )
+		return iGroups[aGroupIndex];
+	else
+		return NULL;
+	}
+
+EXPORT_C TInt COpenFontLinkedTypefaceSpecification::GroupCount() const
+	{
+	return iGroups.Count();
+	}
+
+COpenFontLinkedTypefaceSpecificationBody::COpenFontLinkedTypefaceSpecificationBody()
+	{
+	}
+
+// destructor
+COpenFontLinkedTypefaceSpecificationBody::~COpenFontLinkedTypefaceSpecificationBody()
+	{
+	delete iLinkedTypefaceName;
+	iTypefaces.Reset();
+	}
+
+EXPORT_C COpenFontLinkedTypefaceElementSpec* COpenFontLinkedTypefaceElementSpec::NewLC(const TDesC& aElementName, TInt aGroupId)
+	{
+	COpenFontLinkedTypefaceElementSpec* self = new(ELeave)COpenFontLinkedTypefaceElementSpec(aGroupId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aElementName);
+	return self;
+	}
+
+EXPORT_C COpenFontLinkedTypefaceElementSpec::~COpenFontLinkedTypefaceElementSpec()
+	{
+	delete iElementName;
+	delete iFileName;
+	}
+
+EXPORT_C TPtrC COpenFontLinkedTypefaceElementSpec::ElementName() const
+	{
+	return *iElementName;
+	}
+
+EXPORT_C void COpenFontLinkedTypefaceElementSpec::SetCanonical(TBool aIsCanonical)
+	{
+	iIsCanonical = aIsCanonical;
+	}
+
+EXPORT_C TBool COpenFontLinkedTypefaceElementSpec::Canonical() const
+	{
+	return iIsCanonical;
+	}
+
+EXPORT_C TInt COpenFontLinkedTypefaceElementSpec::GroupId() const
+	{
+	return iGroupId;
+	}
+
+EXPORT_C TPtrC COpenFontLinkedTypefaceElementSpec::FileName() const
+	{
+	return *iFileName;
+	}
+
+EXPORT_C void COpenFontLinkedTypefaceElementSpec::SetFileNameL(const TDesC& aFileName)
+	{
+	iFileName = aFileName.AllocL();
+	}
+
+COpenFontLinkedTypefaceElementSpec::COpenFontLinkedTypefaceElementSpec(TInt aGroupId)
+	{
+	iGroupId = aGroupId;
+	}
+
+void COpenFontLinkedTypefaceElementSpec::ConstructL(const TDesC& aName)
+	{
+	TInt length = aName.Length();
+	if ((length == 0) || (length > KMaxTypefaceNameLength))
+		User::Leave(KErrArgument);
+	iElementName = aName.AllocL();
+	}
+
+void CLinkedTypefaceElementSpec::ConstructL(const TDesC& aName)
+	{
+	TInt length = aName.Length();
+	if ((length == 0) || (length > KMaxTypefaceNameLength))
+		User::Leave(KErrArgument);
+	iElementName = aName.AllocL();
+	}
+
+EXPORT_C CLinkedTypefaceGroup* CLinkedTypefaceGroup::NewLC(TInt aGroupId)
+	{
+	CLinkedTypefaceGroup* self = new (ELeave) CLinkedTypefaceGroup(aGroupId);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+CLinkedTypefaceGroup::CLinkedTypefaceGroup(TInt aGroupId)
+	{
+	iGroupId = aGroupId;
+	iScalingOption = EScalingNone;
+	iBaselineShift = ENoBaselineShift;
+	iBoldnessPercentage = -1;
+	iItalicAngle = -1;
+	}
+
+CLinkedTypefaceGroup::~CLinkedTypefaceGroup()
+	{
+	}
+
+EXPORT_C void CLinkedTypefaceGroup::SetScalingOption(CLinkedTypefaceGroup::TScalingOption aOption)
+	{
+	iScalingOption = aOption;
+	}
+
+EXPORT_C CLinkedTypefaceGroup::TScalingOption CLinkedTypefaceGroup::ScalingOption() const
+	{
+	return iScalingOption;
+	}
+
+EXPORT_C void CLinkedTypefaceGroup::SetBaselineShift(CLinkedTypefaceGroup::TBaselineShift aShift)
+	{
+	iBaselineShift = aShift;
+	}
+
+EXPORT_C CLinkedTypefaceGroup::TBaselineShift CLinkedTypefaceGroup::BaselineShift() const
+	{
+	return iBaselineShift;
+	}
+
+EXPORT_C void CLinkedTypefaceGroup::SetBoldnessPercentage(TInt aPercentage)
+	{
+	iBoldnessPercentage = aPercentage;
+	}
+
+EXPORT_C TInt CLinkedTypefaceGroup::BoldnessPercentage() const
+	{
+	return iBoldnessPercentage;
+	}
+
+EXPORT_C TInt CLinkedTypefaceGroup::GroupId() const
+	{
+	return iGroupId;
+	}
+
+EXPORT_C TInt CLinkedTypefaceGroup::ItalicAngle() const
+	{
+	return iItalicAngle;
+	}
+
+EXPORT_C void CLinkedTypefaceGroup::SetItalicAngle(TInt aAngle)
+	{
+	iItalicAngle = aAngle;
+	}
+
+EXPORT_C void TLinkedTypefaceSpecificationArgs::operator =(const CLinkedTypefaceSpecification& aRhs)
+	{
+	iSize = aRhs.TypefaceCount();
+	iGroupSize = aRhs.GroupCount();
+	iName = aRhs.Name();
+	
+	TInt i;
+	for (i = 0 ; i != iSize ; i++)
+		iTypefaces[i] = aRhs.Typeface(i);
+	
+	for (i = 0 ; i != iGroupSize ; i++)
+		iGroups[i] = aRhs.Group(i);
+	}
+
+EXPORT_C void TLinkedTypefaceSpecificationArgs::operator =(const COpenFontLinkedTypefaceSpecification &aRhs)
+	{
+	iSize = aRhs.TypefaceCount();
+	iGroupSize = aRhs.GroupCount();
+	iName = aRhs.Name();
+	
+	TInt i;
+	for (i = 0 ; i != iSize ; i++)
+		iTypefaces[i] = aRhs.Typeface(i);
+	
+	for (i = 0 ; i != iGroupSize ; i++)
+		iGroups[i] = aRhs.Group(i);
+	}
+
+void TLinkedTypefaceElementSpecArgs::operator = (const CLinkedTypefaceElementSpec* aRhs)
+	{
+	iIsCanonical = aRhs->Canonical();
+	iGroupId = aRhs->GroupId();
+	iName = aRhs->ElementName();
+	}
+
+void TLinkedTypefaceElementSpecArgs::operator = (const COpenFontLinkedTypefaceElementSpec* aRhs)
+	{
+	iIsCanonical = aRhs->Canonical();
+	iGroupId = aRhs->GroupId();
+	iName = aRhs->ElementName();
+	}
+
+void TLinkedTypefaceGroupArgs::operator =(const CLinkedTypefaceGroup* aRhs)
+	{
+	iGroupId = aRhs->GroupId();
+	iScalingOption = aRhs->ScalingOption();
+	iBaselineShift = aRhs->BaselineShift();
+	iBoldnessPercentage = aRhs->BoldnessPercentage();
+	iItalicAngle = aRhs->ItalicAngle();
+	}