MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/textandloc/fontservices/fontstore/src/linkedfonts.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /*

     2 * Copyright (c) 2006-2009 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: 

    15 *

    16 */

    17 

    18 

    19 #include <s32file.h>

    20 #include <graphics/shapeimpl.h>

    21 #include "FNTSTORE.H"

    22 #include "OPENFONT.H"

    23 #include "FNTBODY.H"

    24 #include "FNTSTD.H"

    25 #include <graphics/shaperparams.h>

    26 #include "linkedfonts.h"

    27 #include "linkedfontsprivate.h"

    28 #include "openfontsprivate.h"

    29 #include "fbs.h"

    30 #include <openfontlinkedtypefaceelementspec.h>

    31 #include <graphics/openfontlinkedtypefacespecification.h>

    32 

    33 EXPORT_C CLinkedTypefaceSpecification* CLinkedTypefaceSpecification::NewLC(const TDesC& aTypefaceName)

    34 	{

    35 	CLinkedTypefaceSpecification* self = new (ELeave) CLinkedTypefaceSpecification();

    36 	CleanupStack::PushL(self);

    37 	self->ConstructL(aTypefaceName);

    38 	return self;

    39 	}

    40 

    41 CLinkedTypefaceSpecification::CLinkedTypefaceSpecification()

    42 	{

    43 	}

    44 

    45 void CLinkedTypefaceSpecification::ConstructL(const TDesC &aTypefaceName)

    46 	{

    47 	iBody = new (ELeave) CLinkedTypefaceSpecificationBody();

    48 

    49 	TInt length = aTypefaceName.Length();

    50 	if ((length > KMaxTypefaceNameLength) || (length == 0))

    51 		User::Leave(KErrArgument);

    52 

    53 	iBody->iLinkedTypefaceName = aTypefaceName.AllocL();

    54 	}

    55 

    56 EXPORT_C void CLinkedTypefaceSpecification::AddTypefaceAtIndexL(CLinkedTypefaceElementSpec& aElementSpec, TInt aIndex)

    57 	{

    58 	DoAddTypefaceL(aElementSpec, aIndex);

    59 	}

    60 

    61 EXPORT_C void CLinkedTypefaceSpecification::AddTypefaceAtBackL(CLinkedTypefaceElementSpec& aElementSpec)

    62 	{

    63 	DoAddTypefaceL(aElementSpec, iBody->iTypefaces.Count());

    64 	}

    65 

    66 EXPORT_C TInt CLinkedTypefaceSpecification::RemoveTypeface(TInt aIndex)

    67 	{

    68 	if  ( (aIndex < iBody->iTypefaces.Count()) && (aIndex >= 0) )

    69 		{

    70 		CLinkedTypefaceElementSpec* elementSpec = iBody->iTypefaces[aIndex];

    71 		iBody->iTypefaces.Remove(aIndex);

    72 		delete elementSpec;

    73 		return KErrNone;

    74 		}

    75 	else

    76 		return KErrNotFound;

    77 	}

    78 

    79 EXPORT_C void CLinkedTypefaceSpecification::RegisterLinkedTypefaceL(CFbsTypefaceStore& aStore)

    80 	{

    81 	//Leave if there is no canonical element, or there are multiples.

    82 	//The remaining validation must be performed in fntstore.

    83 	User::LeaveIfError(CanonicalIndex());

    84 	User::LeaveIfError(aStore.RegisterLinkedTypeface(*this));

    85 	}

    86 

    87 EXPORT_C void CLinkedTypefaceSpecification::FetchLinkedTypefaceSpecificationL(CFbsTypefaceStore& aStore)

    88 	{	

    89 	aStore.GetLinkedTypefaceL(*this);

    90 	}

    91 

    92 EXPORT_C TInt CLinkedTypefaceSpecification::TypefaceCount() const

    93 	{

    94 	return iBody->iTypefaces.Count();

    95 	}

    96 

    97 EXPORT_C TPtrC CLinkedTypefaceSpecification::Name() const

    98 	{

    99 	return *iBody->iLinkedTypefaceName;

   100 	}

   101 

   102 EXPORT_C CLinkedTypefaceSpecification::~CLinkedTypefaceSpecification()

   103 	{

   104 	delete iBody;

   105 	}

   106 

   107 EXPORT_C TInt CLinkedTypefaceSpecification::CanonicalIndex()

   108 	{

   109 	TInt index = KErrNotFound;

   110 	for (TInt i = iBody->iTypefaces.Count()-1 ; i >= 0; i--)

   111 		{

   112 		if (iBody->iTypefaces[i]->Canonical())

   113 			{

   114 			if (index == KErrNotFound)

   115 				index = i;

   116 			else 

   117 				return KErrOverflow;

   118 			}

   119 		}

   120 	return index;

   121 	}

   122 

   123 EXPORT_C CLinkedTypefaceElementSpec* CLinkedTypefaceSpecification::Typeface(TInt aIndex) const

   124 	{

   125 	if ((aIndex >= iBody->iTypefaces.Count()) || (aIndex < 0))

   126 		{

   127 		return NULL;

   128 		}

   129 	else

   130 		{

   131 		return iBody->iTypefaces[aIndex];

   132 		}

   133 	}

   134 

   135 void CLinkedTypefaceSpecification::DoAddTypefaceL(CLinkedTypefaceElementSpec& aElementSpec, TInt aPos)

   136 	{

   137 	if (iBody->iTypefaces.Count() == KMaxLinkedTypefaces)

   138 		User::Leave(KErrOverflow);

   139 	

   140 	TInt err = iBody->iTypefaces.Find(&aElementSpec);

   141 

   142 	if (err != KErrNotFound)

   143 		User::Leave(KErrAlreadyExists);

   144 	

   145 	if (aElementSpec.Canonical() && CanonicalIndex() != KErrNotFound)

   146 		User::Leave(KErrArgument);

   147 

   148 	if (GroupById(aElementSpec.GroupId()) == NULL)

   149 		User::Leave(KErrArgument);

   150 	

   151 	err = iBody->iTypefaces.Insert(&aElementSpec, aPos);

   152 

   153 	User::LeaveIfError(err);

   154 	}

   155 

   156 EXPORT_C void CLinkedTypefaceSpecification::AddLinkedTypefaceGroupL(CLinkedTypefaceGroup& aGroup)

   157 	{

   158 	if (iBody->iGroups.Count() == KMaxLinkedTypefaceGroups)

   159 		User::Leave(KErrOverflow);

   160 	

   161 	for (TInt i = iBody->iGroups.Count()-1 ; i >= 0 ; i--)

   162 		{

   163 		if (iBody->iGroups[i]->GroupId() == aGroup.GroupId())

   164 			User::Leave(KErrAlreadyExists);

   165 		}

   166 	iBody->iGroups.AppendL(&aGroup);

   167 	}

   168 

   169 EXPORT_C TInt CLinkedTypefaceSpecification::RemoveLinkedTypefaceGroup(TInt aGroupId)

   170 	{

   171 	//Search for & remove the group if it exists

   172 	CLinkedTypefaceGroup* remove = GroupById(aGroupId);

   173 	//If the group has been found & removed remove all associated typefaces

   174 	if (remove)

   175 		{

   176 		CLinkedTypefaceElementSpec* elementSpec;

   177 		for (TInt i = iBody->iTypefaces.Count()-1 ; i >= 0 ; i--)

   178 			{

   179 			elementSpec = iBody->iTypefaces[i];

   180 			if (elementSpec->GroupId() == aGroupId)

   181 				RemoveTypeface(i);

   182 			}

   183 		iBody->iGroups.Remove(iBody->iGroups.Find(remove));

   184 		delete remove;

   185 		return KErrNone;

   186 		}

   187 	return KErrNotFound;

   188 	}

   189 

   190 EXPORT_C CLinkedTypefaceGroup* CLinkedTypefaceSpecification::GroupById(TInt aGroupId) const

   191 	{

   192 	TInt index;

   193 	TBool found = EFalse;

   194 	for (index = iBody->iGroups.Count()-1; index != -1 ; index--)

   195 		{

   196 		if (iBody->iGroups[index]->GroupId() == aGroupId)

   197 			{

   198 			found = ETrue;

   199 			break;

   200 			}

   201 		}

   202 	

   203 	if (found)

   204 		return iBody->iGroups[index];

   205 	else

   206 		return NULL;

   207 	}

   208 

   209 EXPORT_C CLinkedTypefaceGroup* CLinkedTypefaceSpecification::Group(TInt aGroupIndex) const

   210 	{

   211 	if ( (aGroupIndex >= 0) && (aGroupIndex < iBody->iGroups.Count()) )

   212 		return iBody->iGroups[aGroupIndex];

   213 	else

   214 		return NULL;

   215 	}

   216 

   217 EXPORT_C TInt CLinkedTypefaceSpecification::GroupCount() const

   218 	{

   219 	return iBody->iGroups.Count();

   220 	}

   221 

   222 EXPORT_C void CLinkedTypefaceSpecification::Clear()

   223 	{

   224 	iBody->iGroups.ResetAndDestroy();

   225 	iBody->iTypefaces.ResetAndDestroy();

   226 	}

   227 

   228 EXPORT_C void CLinkedTypefaceSpecification::UpdateLinkedTypefaceL(CFbsTypefaceStore& aStore)

   229 	{

   230 	User::LeaveIfError(aStore.UpdateLinkedTypeface(*this));

   231 	}

   232 

   233 CLinkedTypefaceSpecificationBody::CLinkedTypefaceSpecificationBody()

   234 	{

   235 	}

   236 

   237 CLinkedTypefaceSpecificationBody::~CLinkedTypefaceSpecificationBody()

   238 	{

   239 	delete iLinkedTypefaceName;

   240 	iTypefaces.ResetAndDestroy();

   241 	iGroups.ResetAndDestroy();

   242 	}

   243 

   244 EXPORT_C CLinkedTypefaceElementSpec* CLinkedTypefaceElementSpec::NewLC(const TDesC& aElementName, TInt aGroupId)

   245 	{

   246 	CLinkedTypefaceElementSpec* self = new(ELeave)CLinkedTypefaceElementSpec(aGroupId);

   247 	CleanupStack::PushL(self);

   248 	self->ConstructL(aElementName);

   249 	return self;

   250 	}

   251 

   252 EXPORT_C CLinkedTypefaceElementSpec::~CLinkedTypefaceElementSpec()

   253 	{

   254 	delete iElementName;

   255 	}

   256 

   257 EXPORT_C TPtrC CLinkedTypefaceElementSpec::ElementName() const

   258 	{

   259 	return *iElementName;

   260 	}

   261 

   262 EXPORT_C void CLinkedTypefaceElementSpec::SetCanonical(TBool aIsCanonical)

   263 	{

   264 	iIsCanonical = aIsCanonical;

   265 	}

   266 

   267 EXPORT_C TBool CLinkedTypefaceElementSpec::Canonical() const

   268 	{

   269 	return iIsCanonical;

   270 	}

   271 

   272 CLinkedTypefaceElementSpec::CLinkedTypefaceElementSpec(TInt aGroupId)

   273 	{

   274 	iGroupId = aGroupId;

   275 	iIsCanonical = EFalse;

   276 	}

   277 

   278 EXPORT_C TInt CLinkedTypefaceElementSpec::GroupId() const

   279 	{

   280 	return iGroupId;

   281 	}

   282 

   283 EXPORT_C COpenFontLinkedTypefaceSpecification* COpenFontLinkedTypefaceSpecification::NewLC(const TDesC& aTypefaceName)

   284 	{

   285 	COpenFontLinkedTypefaceSpecification* self = new (ELeave) COpenFontLinkedTypefaceSpecification();

   286 	CleanupStack::PushL(self);

   287 	self->ConstructL(aTypefaceName);

   288 	return self;

   289 	}

   290 

   291 EXPORT_C COpenFontLinkedTypefaceSpecification* COpenFontLinkedTypefaceSpecification::NewLC(const TLinkedTypefaceSpecificationArgs& aSpecArgs)

   292 	{

   293 	COpenFontLinkedTypefaceSpecification* self = new (ELeave) COpenFontLinkedTypefaceSpecification();

   294 	CleanupStack::PushL(self);

   295 	self->ConstructL(aSpecArgs);

   296 	return self;

   297 	}

   298 

   299 COpenFontLinkedTypefaceSpecification::COpenFontLinkedTypefaceSpecification()

   300 	{

   301 	}

   302 

   303 void COpenFontLinkedTypefaceSpecification::ConstructL(const TDesC &aTypefaceName)

   304 	{

   305 	TInt length = aTypefaceName.Length();

   306 	if ((length > KMaxTypefaceNameLength) || (length == 0))

   307 		User::Leave(KErrArgument);

   308 

   309 	iLinkedTypefaceName = aTypefaceName.AllocL();

   310 	}

   311 

   312 void COpenFontLinkedTypefaceSpecification::ConstructL(const TLinkedTypefaceSpecificationArgs& aSpecArgs)

   313 	{

   314 	iLinkedTypefaceName = aSpecArgs.iName.AllocL();

   315 

   316 	TInt i;

   317 	

   318 	for (i = 0; i != aSpecArgs.iGroupSize ; i++)

   319 		{

   320 		CLinkedTypefaceGroup* grp = CLinkedTypefaceGroup::NewLC(aSpecArgs.iGroups[i].iGroupId);

   321 		grp->SetBaselineShift(aSpecArgs.iGroups[i].iBaselineShift);

   322 		grp->SetBoldnessPercentage(aSpecArgs.iGroups[i].iBoldnessPercentage);

   323 		grp->SetItalicAngle(aSpecArgs.iGroups[i].iItalicAngle);

   324 		grp->SetScalingOption(aSpecArgs.iGroups[i].iScalingOption);

   325 		AddLinkedTypefaceGroupL(*grp);

   326 		CleanupStack::Pop(grp);

   327 		}

   328 	

   329 	for (i = 0 ; i != aSpecArgs.iSize ; i++)

   330 		{

   331 		COpenFontLinkedTypefaceElementSpec* es = COpenFontLinkedTypefaceElementSpec::NewLC(aSpecArgs.iTypefaces[i].iName, aSpecArgs.iTypefaces[i].iGroupId);

   332 		es->SetCanonical(aSpecArgs.iTypefaces[i].iIsCanonical);

   333 		AddTypefaceAtBackL(*es);

   334 		CleanupStack::Pop(es);

   335 		}

   336 	

   337 	//ASSERT Can. Indexs match.

   338 	}

   339 

   340 EXPORT_C COpenFontLinkedTypefaceSpecification::~COpenFontLinkedTypefaceSpecification()

   341 	{

   342 	delete iLinkedTypefaceName;

   343 	iTypefaces.ResetAndDestroy();

   344 	iTypefaces.Close();

   345 	iGroups.ResetAndDestroy();

   346 	iGroups.Close();

   347 	}

   348 

   349 EXPORT_C void COpenFontLinkedTypefaceSpecification::AddTypefaceAtIndexL(COpenFontLinkedTypefaceElementSpec& aElementSpec, TInt aIndex)

   350 	{

   351 	DoAddTypefaceL(aElementSpec, aIndex);

   352 	}

   353 

   354 EXPORT_C void COpenFontLinkedTypefaceSpecification::AddTypefaceAtBackL(COpenFontLinkedTypefaceElementSpec& aElementSpec)

   355 	{

   356 	DoAddTypefaceL(aElementSpec, iTypefaces.Count());

   357 	}

   358 

   359 EXPORT_C TInt COpenFontLinkedTypefaceSpecification::RemoveTypeface(TInt aIndex)

   360 	{

   361 	if  ( (aIndex < iTypefaces.Count()) && (aIndex >= 0) )

   362 		{

   363 		COpenFontLinkedTypefaceElementSpec* elementSpec = iTypefaces[aIndex];

   364 		iTypefaces.Remove(aIndex);

   365 

   366 		delete elementSpec;

   367 		return KErrNone;

   368 		}

   369 	else

   370 		return KErrNotFound;

   371 	}

   372 

   373 EXPORT_C TInt COpenFontLinkedTypefaceSpecification::TypefaceCount() const

   374 	{

   375 	return iTypefaces.Count();

   376 	}

   377 

   378 EXPORT_C TPtrC COpenFontLinkedTypefaceSpecification::Name() const

   379 	{

   380 	return *iLinkedTypefaceName;

   381 	}

   382 

   383 EXPORT_C TInt COpenFontLinkedTypefaceSpecification::CanonicalIndex() const

   384 	{

   385 	TInt index = KErrNotFound;

   386 	for (TInt i = iTypefaces.Count()-1 ; i >= 0; i--)

   387 		{

   388 		if (iTypefaces[i]->Canonical())

   389 			{

   390 			if (index == KErrNotFound)

   391 				index = i;

   392 			else 

   393 				return KErrOverflow;

   394 			}

   395 		}

   396 	return index;

   397 	}

   398 

   399 EXPORT_C COpenFontLinkedTypefaceElementSpec* COpenFontLinkedTypefaceSpecification::Typeface(TInt aIndex) const

   400 	{

   401 	if ((aIndex >= iTypefaces.Count()) || (aIndex < 0))

   402 		{

   403 		return NULL;

   404 		}

   405 	else

   406 		{

   407 		return iTypefaces[aIndex];

   408 		}

   409 	}

   410 

   411 void COpenFontLinkedTypefaceSpecification::DoAddTypefaceL(COpenFontLinkedTypefaceElementSpec& aElementSpec, TInt aPos)

   412 	{

   413 	if (iTypefaces.Count() == KMaxLinkedTypefaces)

   414 		User::Leave(KErrOverflow);

   415 	

   416 	TInt err = iTypefaces.Find(&aElementSpec);

   417 

   418 	if (err != KErrNotFound)

   419 		User::Leave(KErrAlreadyExists);

   420 	

   421 	if (aElementSpec.Canonical() && CanonicalIndex() >= 0)

   422 		User::Leave(KErrArgument);

   423 	

   424 	if (GroupById(aElementSpec.GroupId()) == NULL)

   425 		User::Leave(KErrArgument);

   426 	

   427 	err = iTypefaces.Insert(&aElementSpec, aPos);

   428 

   429 	User::LeaveIfError(err);

   430 	}

   431 

   432 EXPORT_C void COpenFontLinkedTypefaceSpecification::AddLinkedTypefaceGroupL(CLinkedTypefaceGroup& aGroup)

   433 	{

   434 	if (iGroups.Count() == KMaxLinkedTypefaceGroups)

   435 		User::Leave(KErrOverflow);

   436 	

   437 	for (TInt i = iGroups.Count()-1 ; i >= 0 ; i--)

   438 		{

   439 		if (iGroups[i]->GroupId() == aGroup.GroupId())

   440 			User::Leave(KErrAlreadyExists);

   441 		}

   442 	iGroups.AppendL(&aGroup);

   443 	}

   444 

   445 EXPORT_C TInt COpenFontLinkedTypefaceSpecification::RemoveLinkedTypefaceGroup(TInt aGroupId)

   446 	{

   447 	//Search for & remove the group if it exists

   448 	CLinkedTypefaceGroup* remove = GroupById(aGroupId);

   449 	//If the group has been found & removed remove all associated typefaces

   450 	if (remove)

   451 		{

   452 		COpenFontLinkedTypefaceElementSpec* elementSpec;

   453 		for (TInt i = iTypefaces.Count()-1 ; i >= 0 ; i--)

   454 			{

   455 			elementSpec = iTypefaces[i];

   456 			if (elementSpec->GroupId() == aGroupId)

   457 				RemoveTypeface(i);

   458 			}

   459 		iGroups.Remove(iGroups.Find(remove));

   460 		delete remove;

   461 		return KErrNone;

   462 		}

   463 	return KErrNotFound;

   464 	}

   465 

   466 EXPORT_C CLinkedTypefaceGroup* COpenFontLinkedTypefaceSpecification::GroupById(TInt aGroupId) const

   467 	{

   468 	TInt index;

   469 	TBool found = EFalse;

   470 	for (index = iGroups.Count()-1; index != -1 ; index--)

   471 		{

   472 		if (iGroups[index]->GroupId() == aGroupId)

   473 			{

   474 			found = ETrue;

   475 			break;

   476 			}

   477 		}

   478 	

   479 	if (found)

   480 		return iGroups[index];

   481 	else

   482 		return NULL;

   483 	}

   484 

   485 EXPORT_C const CLinkedTypefaceGroup* COpenFontLinkedTypefaceSpecification::Group(TInt aGroupIndex) const

   486 	{

   487 	if ( (aGroupIndex >= 0) && (aGroupIndex < iGroups.Count()) )

   488 		return iGroups[aGroupIndex];

   489 	else

   490 		return NULL;

   491 	}

   492 

   493 EXPORT_C TInt COpenFontLinkedTypefaceSpecification::GroupCount() const

   494 	{

   495 	return iGroups.Count();

   496 	}

   497 

   498 COpenFontLinkedTypefaceSpecificationBody::COpenFontLinkedTypefaceSpecificationBody()

   499 	{

   500 	}

   501 

   502 // destructor

   503 COpenFontLinkedTypefaceSpecificationBody::~COpenFontLinkedTypefaceSpecificationBody()

   504 	{

   505 	delete iLinkedTypefaceName;

   506 	iTypefaces.Reset();

   507 	}

   508 

   509 EXPORT_C COpenFontLinkedTypefaceElementSpec* COpenFontLinkedTypefaceElementSpec::NewLC(const TDesC& aElementName, TInt aGroupId)

   510 	{

   511 	COpenFontLinkedTypefaceElementSpec* self = new(ELeave)COpenFontLinkedTypefaceElementSpec(aGroupId);

   512 	CleanupStack::PushL(self);

   513 	self->ConstructL(aElementName);

   514 	return self;

   515 	}

   516 

   517 EXPORT_C COpenFontLinkedTypefaceElementSpec::~COpenFontLinkedTypefaceElementSpec()

   518 	{

   519 	delete iElementName;

   520 	delete iFileName;

   521 	}

   522 

   523 EXPORT_C TPtrC COpenFontLinkedTypefaceElementSpec::ElementName() const

   524 	{

   525 	return *iElementName;

   526 	}

   527 

   528 EXPORT_C void COpenFontLinkedTypefaceElementSpec::SetCanonical(TBool aIsCanonical)

   529 	{

   530 	iIsCanonical = aIsCanonical;

   531 	}

   532 

   533 EXPORT_C TBool COpenFontLinkedTypefaceElementSpec::Canonical() const

   534 	{

   535 	return iIsCanonical;

   536 	}

   537 

   538 EXPORT_C TInt COpenFontLinkedTypefaceElementSpec::GroupId() const

   539 	{

   540 	return iGroupId;

   541 	}

   542 

   543 EXPORT_C TPtrC COpenFontLinkedTypefaceElementSpec::FileName() const

   544 	{

   545 	return *iFileName;

   546 	}

   547 

   548 EXPORT_C void COpenFontLinkedTypefaceElementSpec::SetFileNameL(const TDesC& aFileName)

   549 	{

   550 	iFileName = aFileName.AllocL();

   551 	}

   552 

   553 COpenFontLinkedTypefaceElementSpec::COpenFontLinkedTypefaceElementSpec(TInt aGroupId)

   554 	{

   555 	iGroupId = aGroupId;

   556 	}

   557 

   558 void COpenFontLinkedTypefaceElementSpec::ConstructL(const TDesC& aName)

   559 	{

   560 	TInt length = aName.Length();

   561 	if ((length == 0) || (length > KMaxTypefaceNameLength))

   562 		User::Leave(KErrArgument);

   563 	iElementName = aName.AllocL();

   564 	}

   565 

   566 void CLinkedTypefaceElementSpec::ConstructL(const TDesC& aName)

   567 	{

   568 	TInt length = aName.Length();

   569 	if ((length == 0) || (length > KMaxTypefaceNameLength))

   570 		User::Leave(KErrArgument);

   571 	iElementName = aName.AllocL();

   572 	}

   573 

   574 EXPORT_C CLinkedTypefaceGroup* CLinkedTypefaceGroup::NewLC(TInt aGroupId)

   575 	{

   576 	CLinkedTypefaceGroup* self = new (ELeave) CLinkedTypefaceGroup(aGroupId);

   577 	CleanupStack::PushL(self);

   578 	return self;

   579 	}

   580 

   581 CLinkedTypefaceGroup::CLinkedTypefaceGroup(TInt aGroupId)

   582 	{

   583 	iGroupId = aGroupId;

   584 	iScalingOption = EScalingNone;

   585 	iBaselineShift = ENoBaselineShift;

   586 	iBoldnessPercentage = -1;

   587 	iItalicAngle = -1;

   588 	}

   589 

   590 CLinkedTypefaceGroup::~CLinkedTypefaceGroup()

   591 	{

   592 	}

   593 

   594 EXPORT_C void CLinkedTypefaceGroup::SetScalingOption(CLinkedTypefaceGroup::TScalingOption aOption)

   595 	{

   596 	iScalingOption = aOption;

   597 	}

   598 

   599 EXPORT_C CLinkedTypefaceGroup::TScalingOption CLinkedTypefaceGroup::ScalingOption() const

   600 	{

   601 	return iScalingOption;

   602 	}

   603 

   604 EXPORT_C void CLinkedTypefaceGroup::SetBaselineShift(CLinkedTypefaceGroup::TBaselineShift aShift)

   605 	{

   606 	iBaselineShift = aShift;

   607 	}

   608 

   609 EXPORT_C CLinkedTypefaceGroup::TBaselineShift CLinkedTypefaceGroup::BaselineShift() const

   610 	{

   611 	return iBaselineShift;

   612 	}

   613 

   614 EXPORT_C void CLinkedTypefaceGroup::SetBoldnessPercentage(TInt aPercentage)

   615 	{

   616 	iBoldnessPercentage = aPercentage;

   617 	}

   618 

   619 EXPORT_C TInt CLinkedTypefaceGroup::BoldnessPercentage() const

   620 	{

   621 	return iBoldnessPercentage;

   622 	}

   623 

   624 EXPORT_C TInt CLinkedTypefaceGroup::GroupId() const

   625 	{

   626 	return iGroupId;

   627 	}

   628 

   629 EXPORT_C TInt CLinkedTypefaceGroup::ItalicAngle() const

   630 	{

   631 	return iItalicAngle;

   632 	}

   633 

   634 EXPORT_C void CLinkedTypefaceGroup::SetItalicAngle(TInt aAngle)

   635 	{

   636 	iItalicAngle = aAngle;

   637 	}

   638 

   639 EXPORT_C void TLinkedTypefaceSpecificationArgs::operator =(const CLinkedTypefaceSpecification& aRhs)

   640 	{

   641 	iSize = aRhs.TypefaceCount();

   642 	iGroupSize = aRhs.GroupCount();

   643 	iName = aRhs.Name();

   644 	

   645 	TInt i;

   646 	for (i = 0 ; i != iSize ; i++)

   647 		iTypefaces[i] = aRhs.Typeface(i);

   648 	

   649 	for (i = 0 ; i != iGroupSize ; i++)

   650 		iGroups[i] = aRhs.Group(i);

   651 	}

   652 

   653 EXPORT_C void TLinkedTypefaceSpecificationArgs::operator =(const COpenFontLinkedTypefaceSpecification &aRhs)

   654 	{

   655 	iSize = aRhs.TypefaceCount();

   656 	iGroupSize = aRhs.GroupCount();

   657 	iName = aRhs.Name();

   658 	

   659 	TInt i;

   660 	for (i = 0 ; i != iSize ; i++)

   661 		iTypefaces[i] = aRhs.Typeface(i);

   662 	

   663 	for (i = 0 ; i != iGroupSize ; i++)

   664 		iGroups[i] = aRhs.Group(i);

   665 	}

   666 

   667 void TLinkedTypefaceElementSpecArgs::operator = (const CLinkedTypefaceElementSpec* aRhs)

   668 	{

   669 	iIsCanonical = aRhs->Canonical();

   670 	iGroupId = aRhs->GroupId();

   671 	iName = aRhs->ElementName();

   672 	}

   673 

   674 void TLinkedTypefaceElementSpecArgs::operator = (const COpenFontLinkedTypefaceElementSpec* aRhs)

   675 	{

   676 	iIsCanonical = aRhs->Canonical();

   677 	iGroupId = aRhs->GroupId();

   678 	iName = aRhs->ElementName();

   679 	}

   680 

   681 void TLinkedTypefaceGroupArgs::operator =(const CLinkedTypefaceGroup* aRhs)

   682 	{

   683 	iGroupId = aRhs->GroupId();

   684 	iScalingOption = aRhs->ScalingOption();

   685 	iBaselineShift = aRhs->BaselineShift();

   686 	iBoldnessPercentage = aRhs->BoldnessPercentage();

   687 	iItalicAngle = aRhs->ItalicAngle();

   688 	}
Symaptic