|
1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Implementation of the TChineseCalendar class. |
|
15 // |
|
16 // |
|
17 |
|
18 // User includes |
|
19 #include "calconv.h" |
|
20 |
|
21 // Constants |
|
22 const TInt KChinStartEpoch = 758325; |
|
23 const TInt KFifteenth = 15; |
|
24 const TInt KDegreesPerMonth = 30; |
|
25 const TInt KMonthsInYear = 12; |
|
26 const TInt KFirstChinYear = -2636; |
|
27 const TInt KYearsInChinCycle = 60; |
|
28 const TInt KCycleOffset = 1; |
|
29 |
|
30 |
|
31 // |
|
32 // Construction/Destruction |
|
33 // |
|
34 |
|
35 //------------------------------------------------------ |
|
36 // Class: TChineseCalendar |
|
37 // Function: TChineseCalendar |
|
38 // Arguments: None |
|
39 // |
|
40 // Comments: Constructer |
|
41 // |
|
42 // Return: None |
|
43 //------------------------------------------------------ |
|
44 EXPORT_C TChineseCalendar::TChineseCalendar() |
|
45 { |
|
46 iStartEpoch = KChinStartEpoch; |
|
47 } |
|
48 |
|
49 //------------------------------------------------------ |
|
50 // Class: TChineseCalendar |
|
51 // Function: CurrentMajorSolarTerm |
|
52 // Arguments: TReal |
|
53 // |
|
54 // Comments: Returns the index of the last major solar term |
|
55 // |
|
56 // Return: see comment |
|
57 //------------------------------------------------------ |
|
58 TReal TChineseCalendar::CurrentMajorSolarTerm(TReal& aJulianDay) const |
|
59 { |
|
60 TReal sigma; |
|
61 TInt sigmaI; |
|
62 |
|
63 AdjustJDToNoon(aJulianDay); |
|
64 |
|
65 sigma = ChineseTimeZone(aJulianDay); |
|
66 sigma = UniversalFromLocal(aJulianDay,sigma); |
|
67 SolarLongitude(sigma,sigma); |
|
68 sigma /= 30.0; |
|
69 Floor(sigmaI,sigma); |
|
70 sigmaI += 2; |
|
71 Amod(sigma,sigmaI,12.0); |
|
72 Round(sigmaI,sigma); |
|
73 return sigmaI; |
|
74 } |
|
75 |
|
76 //------------------------------------------------------ |
|
77 // Class: TChineseCalendar |
|
78 // Function: ChineseTimeZone |
|
79 // Arguments: TReal |
|
80 // |
|
81 // Comments: Determines which time zone to use |
|
82 // |
|
83 // Return: TReal - time zone |
|
84 //------------------------------------------------------ |
|
85 TReal TChineseCalendar::ChineseTimeZone(const TReal& aJulianDay) const |
|
86 { |
|
87 TReal result; |
|
88 TGregorianCalendar greg(aJulianDay); |
|
89 TArithmeticalDate date; |
|
90 |
|
91 greg.GetDate(date); |
|
92 |
|
93 if(date.iYear < 1929) |
|
94 { |
|
95 result = 465.0 + (40.0 / 60.0); |
|
96 } |
|
97 else |
|
98 { |
|
99 result = 480.0; |
|
100 } |
|
101 return result; |
|
102 } |
|
103 |
|
104 //------------------------------------------------------ |
|
105 // Class: TChineseCalendar |
|
106 // Function: ChineseDateNextSolarLongitudeL |
|
107 // Arguments: TReal , TReal |
|
108 // |
|
109 // Comments: calculates the first date on or after the given |
|
110 // julian day when the solar longitude will be a |
|
111 // multiple of aDegrees degrees. |
|
112 // |
|
113 // Return: TInt - see comment |
|
114 //------------------------------------------------------ |
|
115 TInt TChineseCalendar::ChineseDateNextSolarLongitude(TReal& aJulianDay, const TReal& aDegrees) const |
|
116 { |
|
117 TReal chTimeZone; |
|
118 TReal chDateNxtSlrLong; |
|
119 TInt rtn; |
|
120 |
|
121 AdjustJDToNoon(aJulianDay); |
|
122 chTimeZone = ChineseTimeZone(aJulianDay); |
|
123 |
|
124 chDateNxtSlrLong = UniversalFromLocal(aJulianDay,chTimeZone); |
|
125 chDateNxtSlrLong = DateNextSolarLongitude(chDateNxtSlrLong,aDegrees); |
|
126 chDateNxtSlrLong = LocalFromUniversal(chDateNxtSlrLong,chTimeZone); |
|
127 |
|
128 AdjustJDFromNoon(chDateNxtSlrLong); |
|
129 Floor(rtn,chDateNxtSlrLong); |
|
130 |
|
131 return rtn; |
|
132 } |
|
133 |
|
134 |
|
135 //------------------------------------------------------ |
|
136 // Class: TChineseCalendar |
|
137 // Function: MajorSolarTermOnOrAfter |
|
138 // Arguments: TReal |
|
139 // |
|
140 // Comments: Determines the major solar term on or after |
|
141 // the given julian day. |
|
142 // |
|
143 // Return: TReal - see comment |
|
144 //------------------------------------------------------ |
|
145 TReal TChineseCalendar::MajorSolarTermOnOrAfter(TReal& aJulianDay) const |
|
146 { |
|
147 TReal majorSolarTerm; |
|
148 majorSolarTerm = ChineseDateNextSolarLongitude(aJulianDay,KDegreesPerMonth); |
|
149 return majorSolarTerm; |
|
150 } |
|
151 |
|
152 //------------------------------------------------------ |
|
153 // Class: TChineseCalendar |
|
154 // Function: GetDate |
|
155 // Arguments: TChineseDate & |
|
156 // |
|
157 // Comments: This function Determines the chinese date and |
|
158 // places it in the TChineseDate class provided |
|
159 // for the julian day value held internally in the |
|
160 // Chinese class. |
|
161 // |
|
162 // Return: None |
|
163 //------------------------------------------------------ |
|
164 EXPORT_C void TChineseCalendar::GetDate(TChineseDate &aDate) |
|
165 { |
|
166 ChineseFromFixed(aDate,iJulianDay); |
|
167 } |
|
168 |
|
169 |
|
170 //------------------------------------------------------ |
|
171 // Class: TChineseCalendar |
|
172 // Function: ChineseNewMoonBefore |
|
173 // Arguments: TReal |
|
174 // |
|
175 // Comments: corrects for chinese month starting at noon |
|
176 // in Beijing |
|
177 // |
|
178 // Return: TInt - new moon |
|
179 //------------------------------------------------------ |
|
180 TInt TChineseCalendar::ChineseNewMoonBefore(TReal aJulianDay) const |
|
181 { |
|
182 TReal newMoon; |
|
183 TReal timeZone; |
|
184 TInt rtn; |
|
185 |
|
186 AdjustJDToNoon(aJulianDay); |
|
187 |
|
188 timeZone = ChineseTimeZone(aJulianDay); |
|
189 newMoon = UniversalFromLocal(aJulianDay,timeZone); |
|
190 newMoon = NewMoonBefore(newMoon); |
|
191 newMoon = LocalFromUniversal(newMoon,timeZone); |
|
192 |
|
193 AdjustJDFromNoon(newMoon); |
|
194 Floor(rtn,newMoon); |
|
195 |
|
196 return rtn; |
|
197 } |
|
198 |
|
199 //------------------------------------------------------ |
|
200 // Class: TChineseCalendar |
|
201 // Function: ChineseNewMoonOnOrAfter |
|
202 // Arguments: TReal |
|
203 // |
|
204 // Comments: corrects for chinese month starting at noon |
|
205 // in Beijing |
|
206 // |
|
207 // Return: TInt - new moon |
|
208 //------------------------------------------------------ |
|
209 TInt TChineseCalendar::ChineseNewMoonOnOrAfter(TReal aJulianDay) const |
|
210 { |
|
211 TReal newMoon; |
|
212 TReal timeZone; |
|
213 TInt rtn; |
|
214 |
|
215 AdjustJDToNoon(aJulianDay); |
|
216 |
|
217 timeZone = ChineseTimeZone(aJulianDay); |
|
218 newMoon = UniversalFromLocal(aJulianDay,timeZone); |
|
219 newMoon = NewMoonAtOrAfter(newMoon); |
|
220 newMoon = LocalFromUniversal(newMoon,timeZone); |
|
221 |
|
222 AdjustJDFromNoon(newMoon); |
|
223 Floor(rtn,newMoon); |
|
224 |
|
225 return rtn; |
|
226 } |
|
227 |
|
228 //------------------------------------------------------ |
|
229 // Class: TChineseCalendar |
|
230 // Function: NoMajorSolarTerm |
|
231 // Arguments: TReal |
|
232 // |
|
233 // Comments: Determines whether a given month lacks a |
|
234 // major solar term. The first month without |
|
235 // a major solar term is a leap month. |
|
236 // |
|
237 // Return: TBool - ETrue if month has no major solar term |
|
238 //------------------------------------------------------ |
|
239 TBool TChineseCalendar::NoMajorSolarTerm(TReal aJulianDay) const |
|
240 { |
|
241 TReal chinNewMoon; |
|
242 TReal currentMajSolTrm1; |
|
243 TReal currentMajSolTrm2; |
|
244 |
|
245 chinNewMoon = ChineseNewMoonOnOrAfter(aJulianDay + KCalConvDayOffsetByOne); |
|
246 currentMajSolTrm1 = CurrentMajorSolarTerm(chinNewMoon); |
|
247 currentMajSolTrm2 = CurrentMajorSolarTerm(aJulianDay); |
|
248 |
|
249 return(currentMajSolTrm1 == currentMajSolTrm2); |
|
250 } |
|
251 |
|
252 //------------------------------------------------------ |
|
253 // Class: TChineseCalendar |
|
254 // Function: PriorLeapMonth |
|
255 // Arguments: TReal , TReal |
|
256 // |
|
257 // Comments: this function is used in conjunction with |
|
258 // NoMajorSolarTerm() to ensure that only the |
|
259 // first month missing a major solar term is |
|
260 // a leap month |
|
261 // |
|
262 // Return: TBool - |
|
263 //------------------------------------------------------ |
|
264 TBool TChineseCalendar::PriorLeapMonth(TReal& aMnthprime, TReal aMnth) const |
|
265 { |
|
266 TBool rtn,majorSolarTerm; |
|
267 TReal newMoonBefore; |
|
268 |
|
269 majorSolarTerm = NoMajorSolarTerm(aMnth); |
|
270 newMoonBefore = ChineseNewMoonBefore(aMnth); |
|
271 |
|
272 if((aMnth >= aMnthprime) && |
|
273 (PriorLeapMonth(aMnthprime,newMoonBefore) || majorSolarTerm)) |
|
274 { |
|
275 rtn = ETrue; |
|
276 } |
|
277 else |
|
278 { |
|
279 rtn = EFalse; |
|
280 } |
|
281 return rtn; |
|
282 } |
|
283 |
|
284 //------------------------------------------------------ |
|
285 // Class: TChineseCalendar |
|
286 // Function: ChineseNewYear |
|
287 // Arguments: TInt |
|
288 // |
|
289 // Comments: Determines the chinese new year |
|
290 // |
|
291 // Return: TReal - Julian day of the start of the given year |
|
292 //------------------------------------------------------ |
|
293 TReal TChineseCalendar::ChineseNewYear(TInt aYear) const |
|
294 { |
|
295 TGregorianCalendar greg(iJulianDay); |
|
296 TArithmeticalDate date; |
|
297 TReal solarTerm1; |
|
298 TReal solarTerm2; |
|
299 TReal newMoon1; |
|
300 TReal newMoon2; |
|
301 TReal newMoon3; |
|
302 TReal rtn; |
|
303 TBool majorSolarTerm1; |
|
304 TBool majorSolarTerm2; |
|
305 TReal tempReal; |
|
306 TInt tempInt; |
|
307 |
|
308 // get solar term 1 |
|
309 date.iDay = KFifteenth; |
|
310 date.iMonth = EDecember + KCalConvMonthOffsetByOne; |
|
311 date.iYear = aYear - KCalConvYearOffsetByOne; |
|
312 solarTerm1 = greg.GregToJulianDay(date); |
|
313 solarTerm1 = MajorSolarTermOnOrAfter(solarTerm1); |
|
314 |
|
315 // get solar term 2 |
|
316 date.iDay = KFifteenth; |
|
317 date.iMonth = EDecember + KCalConvMonthOffsetByOne; |
|
318 date.iYear = aYear; |
|
319 solarTerm2 = greg.GregToJulianDay(date); |
|
320 solarTerm2 = MajorSolarTermOnOrAfter(solarTerm2); |
|
321 |
|
322 // get new moon 1 |
|
323 newMoon1 = ChineseNewMoonOnOrAfter(solarTerm1 + KCalConvDayOffsetByOne); |
|
324 |
|
325 // get new moon 2 |
|
326 newMoon2 = ChineseNewMoonOnOrAfter(newMoon1 + KCalConvDayOffsetByOne); |
|
327 |
|
328 // get new moon 3 |
|
329 newMoon3 = ChineseNewMoonBefore(solarTerm2 + KCalConvDayOffsetByOne); |
|
330 |
|
331 // perform chinese new year calculation |
|
332 tempReal = (newMoon3 - newMoon1) / KMeanSynodicMonth; |
|
333 Round(tempInt,tempReal); |
|
334 majorSolarTerm1 = NoMajorSolarTerm(newMoon1); |
|
335 majorSolarTerm2 = NoMajorSolarTerm(newMoon2); |
|
336 if((tempInt == KMonthsInYear) && (majorSolarTerm1 || majorSolarTerm2)) |
|
337 { |
|
338 rtn = ChineseNewMoonOnOrAfter(newMoon2 + KCalConvDayOffsetByOne); |
|
339 } |
|
340 else |
|
341 { |
|
342 rtn = newMoon2; |
|
343 } |
|
344 return rtn; |
|
345 } |
|
346 |
|
347 //------------------------------------------------------ |
|
348 // Class: TChineseCalendar |
|
349 // Function: SetDate |
|
350 // Arguments: TChineseDate& |
|
351 // |
|
352 // Comments: this function sets the julian day value |
|
353 // in the base class from the given |
|
354 // TChineseDate |
|
355 // |
|
356 // Return: None |
|
357 //------------------------------------------------------ |
|
358 EXPORT_C TInt TChineseCalendar::SetDate(const TChineseDate &aDate) |
|
359 { |
|
360 TReal jD; |
|
361 TChineseDate ChinDate = aDate; |
|
362 if(ValidDate(ChinDate)==EFalse) |
|
363 { |
|
364 return KCalConInvalidDate; |
|
365 } |
|
366 |
|
367 ChineseToFixed(aDate,jD); |
|
368 iJulianDay = jD; |
|
369 return KErrNone; |
|
370 } |
|
371 |
|
372 //------------------------------------------------------ |
|
373 // Class: TChineseCalendar |
|
374 // Function: ChineseFromFixed |
|
375 // Arguments: TChineseDate &, TReal |
|
376 // |
|
377 // Comments: this function converts a julian day value to |
|
378 // a chinese date in the form TChineseDate |
|
379 // |
|
380 // Return: None |
|
381 //------------------------------------------------------ |
|
382 void TChineseCalendar::ChineseFromFixed(TChineseDate &aDate, const TReal& aJulianDay) const |
|
383 { |
|
384 TGregorianCalendar greg(aJulianDay); |
|
385 TArithmeticalDate date; |
|
386 TReal solarTerm1; |
|
387 TReal solarTerm2; |
|
388 TReal lunarTerm1; |
|
389 TReal lunarTerm2; |
|
390 TReal lunarTerm3; |
|
391 TInt leapYear; |
|
392 TInt year; |
|
393 TInt elapsedYears; |
|
394 TBool majorSolarTerm; |
|
395 TReal tempReal; |
|
396 TInt tempInt; |
|
397 |
|
398 // get the Gregorian date |
|
399 greg.GetDate(date); |
|
400 year = date.iYear; |
|
401 |
|
402 // get solar term 1 |
|
403 date.iDay = KFifteenth; |
|
404 date.iMonth = EDecember + KCalConvMonthOffsetByOne; |
|
405 date.iYear = year - KCalConvYearOffsetByOne; |
|
406 solarTerm1 = greg.GregToJulianDay(date); |
|
407 solarTerm1 = MajorSolarTermOnOrAfter(solarTerm1); |
|
408 |
|
409 // get solar term 2 |
|
410 date.iDay = KFifteenth; |
|
411 date.iMonth = EDecember + KCalConvMonthOffsetByOne; |
|
412 date.iYear = year; |
|
413 solarTerm2 = greg.GregToJulianDay(date); |
|
414 solarTerm2 = MajorSolarTermOnOrAfter(solarTerm2); |
|
415 |
|
416 // get lunar term 1 |
|
417 if((solarTerm1 <= aJulianDay) && (aJulianDay < solarTerm2)) |
|
418 { |
|
419 lunarTerm1 = solarTerm1 + KCalConvDayOffsetByOne; |
|
420 } |
|
421 else |
|
422 { |
|
423 lunarTerm1 = solarTerm2 + KCalConvDayOffsetByOne; |
|
424 } |
|
425 lunarTerm1 = ChineseNewMoonOnOrAfter(lunarTerm1); |
|
426 |
|
427 // get lunar term 2 |
|
428 if((solarTerm1 <= aJulianDay) && (aJulianDay < solarTerm2)) |
|
429 { |
|
430 lunarTerm2 = solarTerm2 + KCalConvDayOffsetByOne; |
|
431 } |
|
432 else |
|
433 { |
|
434 date.iDay = KFifteenth; |
|
435 date.iMonth = EDecember + KCalConvMonthOffsetByOne; |
|
436 date.iYear = year + KCalConvYearOffsetByOne; |
|
437 lunarTerm2 = greg.GregToJulianDay(date); |
|
438 lunarTerm2 = MajorSolarTermOnOrAfter(lunarTerm2) + KCalConvDayOffsetByOne; |
|
439 } |
|
440 lunarTerm2 = ChineseNewMoonBefore(lunarTerm2); |
|
441 |
|
442 // get Lunar term 3 |
|
443 lunarTerm3 = aJulianDay + KCalConvDayOffsetByOne; |
|
444 lunarTerm3 = ChineseNewMoonBefore(lunarTerm3); |
|
445 |
|
446 // get leap year |
|
447 tempReal = ((lunarTerm2 - lunarTerm1) / KMeanSynodicMonth); |
|
448 Round(tempInt,tempReal); |
|
449 if(tempInt == KMonthsInYear) |
|
450 { |
|
451 leapYear = ETrue; |
|
452 } |
|
453 else |
|
454 { |
|
455 leapYear = EFalse; |
|
456 } |
|
457 |
|
458 // get month |
|
459 tempReal = ((lunarTerm3 - lunarTerm1) / KMeanSynodicMonth); |
|
460 Round(tempInt,tempReal); |
|
461 if(leapYear && PriorLeapMonth(lunarTerm1,lunarTerm3)) |
|
462 { |
|
463 tempInt--; |
|
464 } |
|
465 Amod(tempReal,tempInt,KMonthsInYear); |
|
466 Round(aDate.iMonth,tempReal); |
|
467 |
|
468 // get leap month |
|
469 majorSolarTerm = NoMajorSolarTerm(lunarTerm3); |
|
470 if((leapYear) && majorSolarTerm && (!PriorLeapMonth(lunarTerm1,ChineseNewMoonBefore(lunarTerm3)))) |
|
471 { |
|
472 aDate.iLeapMonth = ETrue; |
|
473 } |
|
474 else |
|
475 { |
|
476 aDate.iLeapMonth = EFalse; |
|
477 } |
|
478 |
|
479 // get elapsed years |
|
480 elapsedYears = year - KFirstChinYear; |
|
481 |
|
482 date.iDay = KCalConvFirstDay; |
|
483 date.iMonth = EJuly + KCalConvMonthOffsetByOne; |
|
484 date.iYear = year; |
|
485 tempReal = greg.GregToJulianDay(date); |
|
486 if((aDate.iMonth < (ENovember + KCalConvMonthOffsetByOne)) || (aJulianDay > tempReal)) |
|
487 { |
|
488 elapsedYears++; |
|
489 } |
|
490 |
|
491 // get cycle |
|
492 tempReal = (elapsedYears - KCalConvYearOffsetByOne) / KYearsInChinCycle; |
|
493 Floor(aDate.iCycle,tempReal); |
|
494 aDate.iCycle++; |
|
495 |
|
496 // get year |
|
497 Amod(tempReal,elapsedYears,KYearsInChinCycle); |
|
498 Round(aDate.iYear,tempReal); |
|
499 |
|
500 // get day |
|
501 Floor(tempInt,aJulianDay); |
|
502 aDate.iDay = tempInt; |
|
503 Floor(tempInt,lunarTerm3); |
|
504 aDate.iDay -= tempInt; |
|
505 aDate.iDay += KCalConvDayOffsetByOne; |
|
506 } |
|
507 |
|
508 //------------------------------------------------------ |
|
509 // Class: TChineseCalendar |
|
510 // Function: ValidDate |
|
511 // Arguments: TChineseDate & |
|
512 // |
|
513 // Comments: This function Determines whether the given |
|
514 // date is a valid chinese date |
|
515 // |
|
516 // Return: TBool - ETrue if date is valid, else EFalse |
|
517 //------------------------------------------------------ |
|
518 TBool TChineseCalendar::ValidDate(const TChineseDate &aDate) const |
|
519 { |
|
520 TReal jD; |
|
521 TChineseDate chinDate; |
|
522 |
|
523 ChineseToFixed(aDate,jD); |
|
524 ChineseFromFixed(chinDate,jD); |
|
525 |
|
526 if(aDate.operator==(chinDate)) |
|
527 return ETrue; |
|
528 else |
|
529 return EFalse; |
|
530 } |
|
531 |
|
532 //------------------------------------------------------ |
|
533 // Class: TChineseCalendar |
|
534 // Function: ChineseToDateTime |
|
535 // Arguments: TDateTime & |
|
536 // |
|
537 // Comments: This function converts the date held within |
|
538 // the TChineseCalendar class to a TDateTime format and |
|
539 // places it in the TDateTime class provided. |
|
540 // |
|
541 // Return: void |
|
542 //------------------------------------------------------ |
|
543 EXPORT_C void TChineseCalendar::ChineseToDateTime(TDateTime &aDT) |
|
544 { |
|
545 TArithmeticalDate gregDate; |
|
546 TGregorianCalendar greg(iJulianDay); |
|
547 |
|
548 greg.GregFromJulianDay(gregDate,iJulianDay); |
|
549 |
|
550 aDT.SetMicroSecond(0); |
|
551 aDT.SetSecond(0); |
|
552 aDT.SetMinute(0); |
|
553 aDT.SetHour(0); |
|
554 aDT.SetMonth((TMonth)(gregDate.iMonth - KCalConvMonthOffsetByOne)); |
|
555 aDT.SetDay(gregDate.iDay - KCalConvMonthOffsetByOne); |
|
556 aDT.SetYear(gregDate.iYear); |
|
557 } |
|
558 |
|
559 //------------------------------------------------------ |
|
560 // Class: TChineseCalendar |
|
561 // Function: DateTimeToChinese |
|
562 // Arguments: TDateTime & |
|
563 // |
|
564 // Comments: Sets the date held in the given TDateTime |
|
565 // class to the TChineseCalendar class |
|
566 // |
|
567 // Return: void |
|
568 //------------------------------------------------------ |
|
569 EXPORT_C void TChineseCalendar::DateTimeToChinese(const TDateTime &aDT) |
|
570 { |
|
571 TArithmeticalDate gregDate; |
|
572 TGregorianCalendar greg; |
|
573 |
|
574 gregDate.iDay = aDT.Day() + KCalConvMonthOffsetByOne; |
|
575 gregDate.iMonth = (TInt)aDT.Month() + KCalConvMonthOffsetByOne; |
|
576 gregDate.iYear = aDT.Year(); |
|
577 |
|
578 iJulianDay = greg.GregToJulianDay(gregDate); |
|
579 } |
|
580 |
|
581 //------------------------------------------------------ |
|
582 // Class: TChineseCalendar |
|
583 // Function: ChineseToFixed |
|
584 // Arguments: TChineseDate , TReal & |
|
585 // |
|
586 // Comments: This function converts a chinese date to |
|
587 // to a julian day value. |
|
588 // |
|
589 // Return: void |
|
590 //------------------------------------------------------ |
|
591 void TChineseCalendar::ChineseToFixed(const TChineseDate& aDate, TReal &aJulianDay) const |
|
592 { |
|
593 TInt year; |
|
594 TReal newYear; |
|
595 TReal pi; |
|
596 TReal priorNewMoon; |
|
597 TReal yearReal; |
|
598 TChineseDate chinDate; |
|
599 |
|
600 // get year |
|
601 yearReal = (aDate.iCycle - KCycleOffset) * KYearsInChinCycle; |
|
602 Floor(year,yearReal); |
|
603 year += aDate.iYear - KCalConvYearOffsetByOne; |
|
604 year += KFirstChinYear; |
|
605 |
|
606 // get new year |
|
607 newYear = ChineseNewYear(year); |
|
608 |
|
609 // get papa |
|
610 pi = ChineseNewMoonOnOrAfter(newYear + ((aDate.iMonth - KCalConvMonthOffsetByOne) * 29)); |
|
611 |
|
612 // get delta |
|
613 ChineseFromFixed(chinDate,pi); |
|
614 |
|
615 // get priorNewMoon |
|
616 if((aDate.iMonth == chinDate.iMonth) && (aDate.iLeapMonth == chinDate.iLeapMonth)) |
|
617 { |
|
618 priorNewMoon = pi; |
|
619 } |
|
620 else |
|
621 { |
|
622 priorNewMoon = ChineseNewMoonOnOrAfter(pi + KCalConvDayOffsetByOne); |
|
623 } |
|
624 |
|
625 aJulianDay = priorNewMoon + aDate.iDay - KCalConvDayOffsetByOne; |
|
626 } |