|
1 /* |
|
2 * Copyright (c) 2002-2004 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 "AknLayout2DataDef.h" |
|
20 #include "AknLayout2Def.h" |
|
21 #include <CdlEngine.h> |
|
22 #include "AknLayout2ScalableDef.h" |
|
23 #define AKNLAYOUT_DEFINE_BYTECODE(name,byte) const TUint8 name = byte; |
|
24 #include "AknLayoutByteCodes.h" |
|
25 |
|
26 const TInt KNumCells = 7; |
|
27 |
|
28 enum TLayoutPanic |
|
29 { |
|
30 ENegativeOffset, |
|
31 EOffsetOutOfRange, |
|
32 EIllegalLineIndex, |
|
33 EMultiLineOffsetOutOfRange |
|
34 }; |
|
35 |
|
36 void Panic(TLayoutPanic aCode) |
|
37 { |
|
38 _LIT(KLayoutPanic, "Layout panic"); |
|
39 User::Panic(KLayoutPanic, aCode); |
|
40 } |
|
41 |
|
42 // local functions |
|
43 |
|
44 TBool IsParentOffset(TInt16 aVal) |
|
45 { |
|
46 const TInt16 pLimits = 0x1000; |
|
47 return ((p-pLimits) <= aVal && aVal <= (p+pLimits)); |
|
48 } |
|
49 |
|
50 void TAknWindowLineLayoutImp::SetlParentOffset(TInt16 aVal, const TRect& aRect) |
|
51 { |
|
52 if (IsParentOffset(aVal)) |
|
53 il = TInt16(aRect.iTl.iX + aVal - p); |
|
54 else |
|
55 il = aVal; |
|
56 } |
|
57 |
|
58 void TAknWindowLineLayoutImp::SettParentOffset(TInt16 aVal, const TRect& aRect) |
|
59 { |
|
60 if (IsParentOffset(aVal)) |
|
61 it = TInt16(aRect.iTl.iY + aVal - p); |
|
62 else |
|
63 it = aVal; |
|
64 } |
|
65 |
|
66 void TAknWindowLineLayoutImp::SetrParentOffset(TInt16 aVal, const TRect& aRect) |
|
67 { |
|
68 if (IsParentOffset(aVal)) |
|
69 ir = TInt16(aRect.iBr.iX + aVal - p); |
|
70 else |
|
71 ir = aVal; |
|
72 } |
|
73 |
|
74 void TAknWindowLineLayoutImp::SetbParentOffset(TInt16 aVal, const TRect& aRect) |
|
75 { |
|
76 if (IsParentOffset(aVal)) |
|
77 ib = TInt16(aRect.iBr.iY + aVal - p); |
|
78 else |
|
79 ib = aVal; |
|
80 } |
|
81 |
|
82 void TAknWindowLineLayoutImp::SetWParentOffset(TInt16 aVal, const TRect& aRect) |
|
83 { |
|
84 if (IsParentOffset(aVal)) |
|
85 iW = TInt16(aRect.Width() + aVal - p); |
|
86 else |
|
87 iW = aVal; |
|
88 } |
|
89 |
|
90 void TAknWindowLineLayoutImp::SetHParentOffset(TInt16 aVal, const TRect& aRect) |
|
91 { |
|
92 if (IsParentOffset(aVal)) |
|
93 iH = TInt16(aRect.Height() + aVal - p); |
|
94 else |
|
95 iH = aVal; |
|
96 } |
|
97 |
|
98 EXPORT_C void TAknWindowLineLayoutImp::SetAllParentOffsets(const TRect& aRect) |
|
99 { |
|
100 SetlParentOffset(il, aRect); |
|
101 SettParentOffset(it, aRect); |
|
102 SetrParentOffset(ir, aRect); |
|
103 SetbParentOffset(ib, aRect); |
|
104 SetWParentOffset(iW, aRect); |
|
105 SetHParentOffset(iH, aRect); |
|
106 } |
|
107 |
|
108 EXPORT_C TAknWindowLineLayout TAknWindowLineLayout::CombineLines(TAknWindowLineLayout aLine, TAknWindowLineLayout aLine2) |
|
109 { |
|
110 if (aLine2.iC != ELayoutEmpty) aLine.iC = aLine2.iC; |
|
111 if (aLine2.il != ELayoutEmpty) aLine.il = aLine2.il; |
|
112 if (aLine2.it != ELayoutEmpty) aLine.it = aLine2.it; |
|
113 if (aLine2.ir != ELayoutEmpty) aLine.ir = aLine2.ir; |
|
114 if (aLine2.ib != ELayoutEmpty) aLine.ib = aLine2.ib; |
|
115 if (aLine2.iW != ELayoutEmpty) aLine.iW = aLine2.iW; |
|
116 if (aLine2.iH != ELayoutEmpty) aLine.iH = aLine2.iH; |
|
117 return aLine; |
|
118 } |
|
119 |
|
120 // |
|
121 // TAknTextLineLayout |
|
122 // |
|
123 |
|
124 void TAknTextLineLayoutImp::SetlParentOffset(TInt16 aVal, const TRect& aRect) |
|
125 { |
|
126 if (IsParentOffset(aVal)) |
|
127 il = TInt16(aRect.iTl.iX + aVal - p); |
|
128 else |
|
129 il = aVal; |
|
130 } |
|
131 |
|
132 |
|
133 void TAknTextLineLayoutImp::SetrParentOffset(TInt16 aVal, const TRect& aRect) |
|
134 { |
|
135 if (IsParentOffset(aVal)) |
|
136 ir = TInt16(aRect.iBr.iX + aVal - p); |
|
137 else |
|
138 ir = aVal; |
|
139 } |
|
140 |
|
141 void TAknTextLineLayoutImp::SetBParentOffset(TInt16 aVal, const TRect& aRect) |
|
142 { |
|
143 if (IsParentOffset(aVal)) |
|
144 iB = TInt16(aRect.iBr.iY + aVal - p); |
|
145 else |
|
146 iB = aVal; |
|
147 } |
|
148 |
|
149 void TAknTextLineLayoutImp::SetWParentOffset(TInt16 aVal, const TRect& aRect) |
|
150 { |
|
151 if (IsParentOffset(aVal)) |
|
152 iW = TInt16(aRect.Width() + aVal - p); |
|
153 else |
|
154 iW = aVal; |
|
155 } |
|
156 |
|
157 |
|
158 EXPORT_C void TAknTextLineLayoutImp::SetAllParentOffsets(const TRect& aRect) |
|
159 { |
|
160 SetlParentOffset(il, aRect); |
|
161 SetrParentOffset(ir, aRect); |
|
162 SetBParentOffset(iB, aRect); |
|
163 SetWParentOffset(iW, aRect); |
|
164 } |
|
165 |
|
166 TUint16 AknLayoutDecodeSupport::DecodeBytes(const TUint8*& aPtr) |
|
167 { |
|
168 TUint8 ch = *aPtr++; |
|
169 switch (ch) |
|
170 { |
|
171 case KByteWord: |
|
172 { |
|
173 TUint16 high = *aPtr++; |
|
174 TUint16 low = *aPtr++; |
|
175 return TUint16((high<<8) | low); |
|
176 } |
|
177 case KByteEmpty: |
|
178 return TUint16(ELayoutEmpty); |
|
179 case KByteP1: |
|
180 { |
|
181 TInt8 offset = *aPtr++; |
|
182 return TUint16(p+offset); |
|
183 } |
|
184 case KByteP2: |
|
185 { |
|
186 TInt16 high = *aPtr++; |
|
187 TUint16 low = *aPtr++; |
|
188 return TUint16(p+((high<<8) | low)); |
|
189 } |
|
190 default: |
|
191 return ch; |
|
192 } |
|
193 } |
|
194 |
|
195 const TUint8* AknLayoutDecodeSupport::DecodeTable(const SImplData* aImplData, TInt aLineIndex) |
|
196 { |
|
197 const TUint16* pApiId = aImplData->iDataLookup + CdlEngine::LastApiId(); |
|
198 const TUint8* pLimits = (const TUint8*)(pApiId-1); |
|
199 __ASSERT_ALWAYS(pLimits[1] <= aLineIndex && aLineIndex <= pLimits[0], Panic(EIllegalLineIndex)); |
|
200 return aImplData->iByteCodedData + aImplData->iDataLookup[(*pApiId) + aLineIndex]; |
|
201 } |
|
202 |
|
203 const TUint8* AknLayoutDecodeSupport::DataPtr(const SImplData* aImplData) |
|
204 { |
|
205 return aImplData->iByteCodedData + aImplData->iDataLookup[CdlEngine::LastApiId()]; |
|
206 } |
|
207 |
|
208 void AknLayoutDecodeSupport::DecodeSimple(TUint16* aLine, const TUint8* aData) |
|
209 { |
|
210 // decode a non-parameterised line by decoding the bytes for each cell |
|
211 for (TInt ii=0; ii<KNumCells; ii++) |
|
212 *aLine++ = DecodeBytes(aData); |
|
213 } |
|
214 |
|
215 void AknLayoutDecodeSupport::DecodeParams(TUint16* aLine, const TUint8* aData, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
216 { |
|
217 // parameters are at the start of the byte coded data |
|
218 const TUint8* paramsPtr = aData; |
|
219 // the cell data follows |
|
220 const TUint8* dataPtr = aData + (aNumParams*2); |
|
221 // decode each cell |
|
222 for (TInt ii=0; ii<KNumCells; ii++) |
|
223 { |
|
224 // calculate the requested and maximum paramter value for this cell |
|
225 TInt max, param; |
|
226 DecodeParam(ii, max, param, paramsPtr, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
227 __ASSERT_ALWAYS(0 <= param && param < max, Panic(EOffsetOutOfRange)); |
|
228 // scan through all values for this cell and record the one indicated by the parameter |
|
229 for (int jj=0; jj<max; jj++) |
|
230 { |
|
231 TUint16 val = DecodeBytes(dataPtr); |
|
232 if (jj == param) |
|
233 *aLine++ = val; |
|
234 } |
|
235 } |
|
236 } |
|
237 |
|
238 void AknLayoutDecodeSupport::DecodeMultiLineParams(TAknTextLineLayoutImp& aLine, const TUint8* aData, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
239 { |
|
240 // this function is similar to DecodeParams, except that extra processing is required |
|
241 // for multiline parameters. |
|
242 TUint16* linePtr = (TUint16*)&aLine; |
|
243 // parameters are at the start of the byte coded data |
|
244 const TUint8* paramsPtr = aData; |
|
245 // the cell data follows |
|
246 const TUint8* dataPtr = aData + (aNumParams*2); |
|
247 TUint16 v0 = 0; |
|
248 for (TInt ii=0; ii<KNumCells; ii++) |
|
249 { |
|
250 // calculate the requested and maximum paramter value for this cell |
|
251 TInt max, param; |
|
252 DecodeParam(ii, max, param, paramsPtr, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
253 __ASSERT_ALWAYS(0 <= param && param < max, Panic(EMultiLineOffsetOutOfRange)); |
|
254 // scan through all values for this cell and record the one indicated by the parameter |
|
255 for (int jj=0; jj<max; jj++) |
|
256 { |
|
257 TUint16 val = DecodeBytes(dataPtr); |
|
258 // cell 3 is the "B" cell. |
|
259 // set baseline skip to the difference between the first and second values for cell B. |
|
260 if (ii == 3 && jj < 2) |
|
261 { |
|
262 if (jj == 0) |
|
263 v0 = val; |
|
264 else |
|
265 aLine.iBaselineSkip = val - v0; |
|
266 } |
|
267 if (jj == param) |
|
268 *linePtr++ = val; |
|
269 } |
|
270 } |
|
271 } |
|
272 |
|
273 TInt AknLayoutDecodeSupport::DecodeNumberOfLinesShown(const TUint8* aParamPtr, TInt& aIndex1, TInt& aIndex2, TInt& aIndex3, TInt& aIndex4) |
|
274 { |
|
275 // For multiline APIs, the parameter order may be changed |
|
276 TInt numberOfLinesShownParamNumber = aParamPtr[0]; |
|
277 TInt numberOfLinesShown; |
|
278 switch (numberOfLinesShownParamNumber) |
|
279 { |
|
280 case 0: |
|
281 numberOfLinesShown = aIndex1; |
|
282 break; |
|
283 case 1: |
|
284 numberOfLinesShown = aIndex2; |
|
285 break; |
|
286 case 2: |
|
287 numberOfLinesShown = aIndex3; |
|
288 break; |
|
289 default: |
|
290 numberOfLinesShown = aIndex4; |
|
291 break; |
|
292 } |
|
293 |
|
294 // index_B will have been removed from the multiline API, so insert a 0 where it |
|
295 // would have been, and shift up the other parameters. |
|
296 TInt indexBParamNumber = aParamPtr[1]; |
|
297 switch (indexBParamNumber) |
|
298 { |
|
299 case 0: |
|
300 aIndex4 = aIndex3; |
|
301 aIndex3 = aIndex2; |
|
302 aIndex2 = aIndex1; |
|
303 aIndex1 = 0; |
|
304 break; |
|
305 case 1: |
|
306 aIndex4 = aIndex3; |
|
307 aIndex3 = aIndex2; |
|
308 aIndex2 = 0; |
|
309 break; |
|
310 case 2: |
|
311 aIndex4 = aIndex3; |
|
312 aIndex3 = 0; |
|
313 break; |
|
314 case 3: |
|
315 aIndex4 = 0; |
|
316 break; |
|
317 default: |
|
318 break; |
|
319 } |
|
320 |
|
321 return numberOfLinesShown; |
|
322 } |
|
323 |
|
324 void AknLayoutDecodeSupport::DecodeParam(TInt aCell, TInt& aMax, TInt& aParam, const TUint8* aParamsPtr, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
325 { |
|
326 // Parameter coding is sequence of pairs of bytes, one for each parameter. |
|
327 // The first byte is a bit field indicating which cells the parameter affects. |
|
328 // The second is the number of items in the cell. |
|
329 TInt ii=0; |
|
330 // This is the bit in the bit-fields we are looking for |
|
331 TInt bit = 1<<aCell; |
|
332 // scan through the parameters and break if one has the relevant bit set for this cell |
|
333 for (; ii<aNumParams; ii++) |
|
334 { |
|
335 if (aParamsPtr[0] & bit) |
|
336 break; |
|
337 aParamsPtr += 2; |
|
338 } |
|
339 |
|
340 if (ii == aNumParams) |
|
341 { |
|
342 // No parameter was found for this cell. |
|
343 aMax = 1; |
|
344 aParam = 0; |
|
345 } |
|
346 else |
|
347 { |
|
348 // A parameter was found for the cell, extract the number of items in the cell |
|
349 // and the correct parameter index value. |
|
350 aMax = aParamsPtr[1]; |
|
351 switch (ii) |
|
352 { |
|
353 case 0: |
|
354 aParam = aIndex1; |
|
355 break; |
|
356 case 1: |
|
357 aParam = aIndex2; |
|
358 break; |
|
359 case 2: |
|
360 aParam = aIndex3; |
|
361 break; |
|
362 default: |
|
363 aParam = aIndex4; |
|
364 break; |
|
365 } |
|
366 } |
|
367 } |
|
368 |
|
369 // The following functions could be factorised, but that would extend the call depth |
|
370 // of an already tricky calculation, with expensive function calls. |
|
371 // So these functions are individually coded - they're short anyway. |
|
372 EXPORT_C void AknLayoutDecodeSupport::WindowLine(TAknWindowLineLayoutImp& aLine, const SImplData* aImplData) |
|
373 { |
|
374 DecodeSimple((TUint16*)&aLine, DataPtr(aImplData)); |
|
375 } |
|
376 |
|
377 EXPORT_C void AknLayoutDecodeSupport::WindowLine(TAknWindowLineLayoutImp& aLine, const SImplData* aImplData, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
378 { |
|
379 DecodeParams((TUint16*)&aLine, DataPtr(aImplData), aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
380 } |
|
381 |
|
382 EXPORT_C void AknLayoutDecodeSupport::WindowLine(TAknWindowLineLayoutImp& aLine, const SImplData* aImplData, const TRect& aRect, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
383 { |
|
384 DecodeParams((TUint16*)&aLine, DataPtr(aImplData), aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
385 aLine.SetAllParentOffsets(aRect); |
|
386 } |
|
387 |
|
388 EXPORT_C void AknLayoutDecodeSupport::TextLine(TAknTextLineLayoutImp& aLine, const SImplData* aImplData) |
|
389 { |
|
390 DecodeSimple((TUint16*)&aLine, DataPtr(aImplData)); |
|
391 aLine.iBaselineSkip = 0; |
|
392 aLine.iNumberOfLinesShown = 1; |
|
393 } |
|
394 |
|
395 EXPORT_C void AknLayoutDecodeSupport::TextLine(TAknTextLineLayoutImp& aLine, const SImplData* aImplData, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
396 { |
|
397 DecodeParams((TUint16*)&aLine, DataPtr(aImplData), aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
398 aLine.iBaselineSkip = 0; |
|
399 aLine.iNumberOfLinesShown = 1; |
|
400 } |
|
401 |
|
402 EXPORT_C void AknLayoutDecodeSupport::TextLine(TAknTextLineLayoutImp& aLine, const SImplData* aImplData, const TRect& aRect, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
403 { |
|
404 DecodeParams((TUint16*)&aLine, DataPtr(aImplData), aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
405 aLine.SetAllParentOffsets(aRect); |
|
406 aLine.iBaselineSkip = 0; |
|
407 aLine.iNumberOfLinesShown = 1; |
|
408 } |
|
409 |
|
410 EXPORT_C void AknLayoutDecodeSupport::MultiLineTextLine(TAknTextLineLayoutImp& aLine, const SImplData* aImplData, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
411 { |
|
412 TInt lastApiId = CdlEngine::LastApiId(); |
|
413 const TUint8* pParamInfo = (const TUint8*)(aImplData->iDataLookup + lastApiId); |
|
414 const TUint8* pData = aImplData->iByteCodedData + aImplData->iDataLookup[lastApiId-1]; |
|
415 aLine.iNumberOfLinesShown = DecodeNumberOfLinesShown(pParamInfo, aIndex1, aIndex2, aIndex3, aIndex4); |
|
416 DecodeMultiLineParams(aLine, pData, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
417 } |
|
418 |
|
419 EXPORT_C void AknLayoutDecodeSupport::MultiLineTextLine(TAknTextLineLayoutImp& aLine, const SImplData* aImplData, const TRect& aRect, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
420 { |
|
421 TInt lastApiId = CdlEngine::LastApiId(); |
|
422 const TUint8* pParamInfo = (const TUint8*)(aImplData->iDataLookup + lastApiId); |
|
423 const TUint8* pData = aImplData->iByteCodedData + aImplData->iDataLookup[lastApiId-1]; |
|
424 aLine.iNumberOfLinesShown = DecodeNumberOfLinesShown(pParamInfo, aIndex1, aIndex2, aIndex3, aIndex4); |
|
425 DecodeMultiLineParams(aLine, pData, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
426 aLine.SetAllParentOffsets(aRect); |
|
427 } |
|
428 |
|
429 EXPORT_C void AknLayoutDecodeSupport::WindowTable(TAknWindowLineLayoutImp& aLine, const SImplData* aImplData, TInt aLineIndex, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
430 { |
|
431 const TUint8* data = DecodeTable(aImplData, aLineIndex); |
|
432 DecodeParams((TUint16*)&aLine, data, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
433 } |
|
434 |
|
435 EXPORT_C void AknLayoutDecodeSupport::WindowTable(TAknWindowLineLayoutImp& aLine, const SImplData* aImplData, TInt aLineIndex, const TRect& aRect, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
436 { |
|
437 const TUint8* data = DecodeTable(aImplData, aLineIndex); |
|
438 DecodeParams((TUint16*)&aLine, data, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
439 aLine.SetAllParentOffsets(aRect); |
|
440 } |
|
441 |
|
442 EXPORT_C void AknLayoutDecodeSupport::TextTable(TAknTextLineLayoutImp& aLine, const SImplData* aImplData, TInt aLineIndex, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
443 { |
|
444 const TUint8* data = DecodeTable(aImplData, aLineIndex); |
|
445 DecodeParams((TUint16*)&aLine, data, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
446 } |
|
447 |
|
448 EXPORT_C void AknLayoutDecodeSupport::TextTable(TAknTextLineLayoutImp& aLine, const SImplData* aImplData, TInt aLineIndex, const TRect& aRect, TInt aNumParams, TInt aIndex1, TInt aIndex2, TInt aIndex3, TInt aIndex4) |
|
449 { |
|
450 const TUint8* data = DecodeTable(aImplData, aLineIndex); |
|
451 DecodeParams((TUint16*)&aLine, data, aNumParams, aIndex1, aIndex2, aIndex3, aIndex4); |
|
452 aLine.SetAllParentOffsets(aRect); |
|
453 } |
|
454 |
|
455 EXPORT_C TAknLayoutTableLimits AknLayoutDecodeSupport::TableLimits(const TUint16* aDataLookup) |
|
456 { |
|
457 TUint8* encoded = (TUint8*)(aDataLookup + CdlEngine::LastApiId()); |
|
458 TAknLayoutTableLimits limits = { encoded[1], encoded[0] }; |
|
459 return limits; |
|
460 } |
|
461 |
|
462 |
|
463 EXPORT_C TAknWindowLineLayout::TAknWindowLineLayout( const TAknWindowComponentLayout& aLine ) |
|
464 { |
|
465 TAknWindowLineLayout line = aLine.LayoutLine(); |
|
466 iC = line.iC; |
|
467 il = line.il; |
|
468 it = line.it; |
|
469 ir = line.ir; |
|
470 ib = line.ib; |
|
471 iW = line.iW; |
|
472 iH = line.iH; |
|
473 } |
|
474 |
|
475 |
|
476 EXPORT_C TAknWindowLineLayout TAknWindowLineLayout::operator=( const TAknWindowComponentLayout& aLine ) |
|
477 { |
|
478 TAknWindowLineLayout line = aLine.LayoutLine(); |
|
479 iC = line.iC; |
|
480 il = line.il; |
|
481 it = line.it; |
|
482 ir = line.ir; |
|
483 ib = line.ib; |
|
484 iW = line.iW; |
|
485 iH = line.iH; |
|
486 return *this; |
|
487 } |
|
488 |
|
489 |
|
490 EXPORT_C TAknTextLineLayout::TAknTextLineLayout( const TAknTextComponentLayout& aLine ) |
|
491 { |
|
492 TAknTextLineLayout line = aLine.LayoutLine(); |
|
493 iC = line.iC; |
|
494 il = line.il; |
|
495 ir = line.ir; |
|
496 iB = line.iB; |
|
497 iW = line.iW; |
|
498 iJ = line.iJ; |
|
499 iFont = line.iFont; |
|
500 } |
|
501 |
|
502 |
|
503 EXPORT_C TAknTextLineLayout TAknTextLineLayout::operator=( const TAknTextComponentLayout& aLine ) |
|
504 { |
|
505 TAknTextLineLayout line = aLine.LayoutLine(); |
|
506 iC = line.iC; |
|
507 il = line.il; |
|
508 ir = line.ir; |
|
509 iB = line.iB; |
|
510 iW = line.iW; |
|
511 iJ = line.iJ; |
|
512 iFont = line.iFont; |
|
513 return *this; |
|
514 } |