QVector<QDate> WeekSchedule::getDatesForWeek(const Week& aweek) const {
QDate newYear(aweek.year(), 1, 1);
QVector<QDate> datesForWeek;
/* find first day in first week, fdfw (in ayear)
- start from 1.1.year => may be in week 1,52 or 53
- if 52 or 53, complete this week until Sunday
- if 1, go back to Monday
go foward (week-1)*7 days
the next 7 days are the days looked for
*/
QDate firstDayFirstWeek;
int numWeek = newYear.weekNumber(); // 1, 52 or 53
if (numWeek == 52 || numWeek == 53) {
firstDayFirstWeek = newYear.addDays(8 - newYear.dayOfWeek());
} else { // if (numWeek == 1)
firstDayFirstWeek = newYear.addDays( (-1)*(newYear.dayOfWeek() - 1) );
}
int daysBefore = Week::daysPerWeek * (aweek.week()-1);
for (int i=0; i<Week::daysPerWeek; i++) {
QDate dfw = firstDayFirstWeek;
dfw = dfw.addDays(daysBefore+i);
datesForWeek.push_back(dfw);
qDebug() << "getDatesForWeek: " << dfw.toString("dd.MM.yyyy");
}
return datesForWeek;
}
/**
* Return the Julian day number of day before the first day of the
* given month in the given extended year.
*
* <p>Note: This method reads the IS_LEAP_MONTH field to determine
* whether the given month is a leap month.
* @param eyear the extended year
* @param month the zero-based month. The month is also determined
* by reading the IS_LEAP_MONTH field.
* @return the Julian day number of the day before the first
* day of the given month and year
* @stable ICU 2.8
*/
int32_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const {
ChineseCalendar *nonConstThis = (ChineseCalendar*)this; // cast away const
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
double m = month;
eyear += (int32_t)ClockMath::floorDivide(m, 12.0, m);
month = (int32_t)m;
}
int32_t gyear = eyear + fEpochYear - 1; // Gregorian year
int32_t theNewYear = newYear(gyear);
int32_t newMoon = newMoonNear(theNewYear + month * 29, TRUE);
int32_t julianDay = newMoon + kEpochStartAsJulianDay;
// Save fields for later restoration
int32_t saveMonth = internalGet(UCAL_MONTH);
int32_t saveIsLeapMonth = internalGet(UCAL_IS_LEAP_MONTH);
// Ignore IS_LEAP_MONTH field if useMonth is false
int32_t isLeapMonth = useMonth ? saveIsLeapMonth : 0;
UErrorCode status = U_ZERO_ERROR;
nonConstThis->computeGregorianFields(julianDay, status);
if (U_FAILURE(status))
return 0;
// This will modify the MONTH and IS_LEAP_MONTH fields (only)
nonConstThis->computeChineseFields(newMoon, getGregorianYear(),
getGregorianMonth(), FALSE);
if (month != internalGet(UCAL_MONTH) ||
isLeapMonth != internalGet(UCAL_IS_LEAP_MONTH)) {
newMoon = newMoonNear(newMoon + SYNODIC_GAP, TRUE);
julianDay = newMoon + kEpochStartAsJulianDay;
}
nonConstThis->internalSet(UCAL_MONTH, saveMonth);
nonConstThis->internalSet(UCAL_IS_LEAP_MONTH, saveIsLeapMonth);
return julianDay - 1;
}
/**
* Compute fields for the Chinese calendar system. This method can
* either set all relevant fields, as required by
* <code>handleComputeFields()</code>, or it can just set the MONTH and
* IS_LEAP_MONTH fields, as required by
* <code>handleComputeMonthStart()</code>.
*
* <p>As a side effect, this method sets {@link #isLeapYear}.
* @param days days after January 1, 1970 0:00 astronomical base zone
* of the date to compute fields for
* @param gyear the Gregorian year of the given date
* @param gmonth the Gregorian month of the given date
* @param setAllFields if true, set the EXTENDED_YEAR, ERA, YEAR,
* DAY_OF_MONTH, and DAY_OF_YEAR fields. In either case set the MONTH
* and IS_LEAP_MONTH fields.
*/
void ChineseCalendar::computeChineseFields(int32_t days, int32_t gyear, int32_t gmonth,
UBool setAllFields) {
// Find the winter solstices before and after the target date.
// These define the boundaries of this Chinese year, specifically,
// the position of month 11, which always contains the solstice.
// We want solsticeBefore <= date < solsticeAfter.
int32_t solsticeBefore;
int32_t solsticeAfter = winterSolstice(gyear);
if (days < solsticeAfter) {
solsticeBefore = winterSolstice(gyear - 1);
} else {
solsticeBefore = solsticeAfter;
solsticeAfter = winterSolstice(gyear + 1);
}
// Find the start of the month after month 11. This will be either
// the prior month 12 or leap month 11 (very rare). Also find the
// start of the following month 11.
int32_t firstMoon = newMoonNear(solsticeBefore + 1, TRUE);
int32_t lastMoon = newMoonNear(solsticeAfter + 1, FALSE);
int32_t thisMoon = newMoonNear(days + 1, FALSE); // Start of this month
// Note: isLeapYear is a member variable
isLeapYear = synodicMonthsBetween(firstMoon, lastMoon) == 12;
int32_t month = synodicMonthsBetween(firstMoon, thisMoon);
if (isLeapYear && isLeapMonthBetween(firstMoon, thisMoon)) {
month--;
}
if (month < 1) {
month += 12;
}
UBool isLeapMonth = isLeapYear &&
hasNoMajorSolarTerm(thisMoon) &&
!isLeapMonthBetween(firstMoon, newMoonNear(thisMoon - SYNODIC_GAP, FALSE));
internalSet(UCAL_MONTH, month-1); // Convert from 1-based to 0-based
internalSet(UCAL_IS_LEAP_MONTH, isLeapMonth?1:0);
if (setAllFields) {
// Extended year and cycle year is based on the epoch year
int32_t extended_year = gyear - fEpochYear;
int cycle_year = gyear - CHINESE_EPOCH_YEAR;
if (month < 11 ||
gmonth >= UCAL_JULY) {
extended_year++;
cycle_year++;
}
int32_t dayOfMonth = days - thisMoon + 1;
internalSet(UCAL_EXTENDED_YEAR, extended_year);
// 0->0,60 1->1,1 60->1,60 61->2,1 etc.
int32_t yearOfCycle;
int32_t cycle = ClockMath::floorDivide(cycle_year - 1, 60, yearOfCycle);
internalSet(UCAL_ERA, cycle + 1);
internalSet(UCAL_YEAR, yearOfCycle + 1);
internalSet(UCAL_DAY_OF_MONTH, dayOfMonth);
// Days will be before the first new year we compute if this
// date is in month 11, leap 11, 12. There is never a leap 12.
// New year computations are cached so this should be cheap in
// the long run.
int32_t theNewYear = newYear(gyear);
if (days < theNewYear) {
theNewYear = newYear(gyear-1);
}
internalSet(UCAL_DAY_OF_YEAR, days - theNewYear + 1);
}
}
