--- /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();
+ }