1 /* 2 * Copyright 2003-2009, Axel Dörfler, axeld@pinc-software.de. 3 * Copyright 2009-2010, Adrien Destugues, pulkomandy@gmail.com. 4 * Copyright 2010-2011, Oliver Tappe <zooey@hirschkaefer.de>. 5 * Distributed under the terms of the MIT License. 6 */ 7 8 9 #include <unicode/uversion.h> 10 #include <FormattingConventions.h> 11 12 #include <AutoDeleter.h> 13 #include <IconUtils.h> 14 #include <List.h> 15 #include <Language.h> 16 #include <Locale.h> 17 #include <LocaleRoster.h> 18 #include <Resources.h> 19 #include <String.h> 20 #include <UnicodeChar.h> 21 22 #include <unicode/datefmt.h> 23 #include <unicode/locid.h> 24 #include <unicode/smpdtfmt.h> 25 #include <unicode/ulocdata.h> 26 #include <ICUWrapper.h> 27 28 #include <iostream> 29 #include <map> 30 #include <monetary.h> 31 #include <new> 32 #include <stdarg.h> 33 #include <stdlib.h> 34 35 36 // #pragma mark - helpers 37 38 39 static bool 40 FormatUsesAmPm(const BString& format) 41 { 42 if (format.Length() == 0) 43 return false; 44 45 bool inQuote = false; 46 for (const char* s = format.String(); *s != '\0'; ++s) { 47 switch (*s) { 48 case '\'': 49 inQuote = !inQuote; 50 break; 51 case 'a': 52 if (!inQuote) 53 return true; 54 break; 55 } 56 } 57 58 return false; 59 } 60 61 62 static void 63 CoerceFormatTo12HourClock(BString& format) 64 { 65 char* s = format.LockBuffer(format.Length()); 66 if (s == NULL) 67 return; 68 69 // change format to use h instead of H, k instead of K, and append an 70 // am/pm marker 71 bool inQuote = false; 72 for (; *s != '\0'; ++s) { 73 switch (*s) { 74 case '\'': 75 inQuote = !inQuote; 76 break; 77 case 'H': 78 if (!inQuote) 79 *s = 'h'; 80 break; 81 case 'K': 82 if (!inQuote) 83 *s = 'k'; 84 break; 85 } 86 } 87 format.UnlockBuffer(format.Length()); 88 89 format.Append(" a"); 90 } 91 92 93 static void 94 CoerceFormatTo24HourClock(BString& format) 95 { 96 char* buffer = format.LockBuffer(format.Length()); 97 char* currentPos = buffer; 98 if (currentPos == NULL) 99 return; 100 101 // change the format to use H instead of h, K instead of k, and determine 102 // and remove the am/pm marker (including leading whitespace) 103 bool inQuote = false; 104 bool lastWasWhitespace = false; 105 uint32 ch; 106 const char* amPmStartPos = NULL; 107 const char* amPmEndPos = NULL; 108 const char* lastWhitespaceStart = NULL; 109 for (char* previousPos = currentPos; (ch = BUnicodeChar::FromUTF8( 110 (const char**)¤tPos)) != 0; previousPos = currentPos) { 111 switch (ch) { 112 case '\'': 113 inQuote = !inQuote; 114 break; 115 case 'h': 116 if (!inQuote) 117 *previousPos = 'H'; 118 break; 119 case 'k': 120 if (!inQuote) 121 *previousPos = 'K'; 122 break; 123 case 'a': 124 if (!inQuote) { 125 if (lastWasWhitespace) 126 amPmStartPos = lastWhitespaceStart; 127 else 128 amPmStartPos = previousPos; 129 amPmEndPos = currentPos; 130 } 131 break; 132 default: 133 if (!inQuote && BUnicodeChar::IsWhitespace(ch)) { 134 if (!lastWasWhitespace) { 135 lastWhitespaceStart = previousPos; 136 lastWasWhitespace = true; 137 } 138 continue; 139 } 140 } 141 lastWasWhitespace = false; 142 } 143 144 format.UnlockBuffer(format.Length()); 145 if (amPmStartPos != NULL && amPmEndPos > amPmStartPos) 146 format.Remove(amPmStartPos - buffer, amPmEndPos - amPmStartPos); 147 } 148 149 150 static void 151 CoerceFormatToAbbreviatedTimezone(BString& format) 152 { 153 char* s = format.LockBuffer(format.Length()); 154 if (s == NULL) 155 return; 156 157 // replace a single 'z' with 'V' 158 bool inQuote = false; 159 bool lastWasZ = false; 160 for (; *s != '\0'; ++s) { 161 switch (*s) { 162 case '\'': 163 inQuote = !inQuote; 164 break; 165 case 'z': 166 if (!inQuote && !lastWasZ && *(s+1) != 'z') 167 *s = 'V'; 168 lastWasZ = true; 169 continue; 170 } 171 lastWasZ = false; 172 } 173 format.UnlockBuffer(format.Length()); 174 } 175 176 177 // #pragma mark - BFormattingConventions 178 179 180 enum ClockHoursState { 181 CLOCK_HOURS_UNSET = 0, 182 CLOCK_HOURS_24, 183 CLOCK_HOURS_12 184 }; 185 186 187 BFormattingConventions::BFormattingConventions(const char* id) 188 : 189 fCachedUse24HourClock(CLOCK_HOURS_UNSET), 190 fExplicitUse24HourClock(CLOCK_HOURS_UNSET), 191 fUseStringsFromPreferredLanguage(false), 192 fICULocale(new icu::Locale(id)) 193 { 194 } 195 196 197 BFormattingConventions::BFormattingConventions( 198 const BFormattingConventions& other) 199 : 200 fCachedNumericFormat(other.fCachedNumericFormat), 201 fCachedMonetaryFormat(other.fCachedMonetaryFormat), 202 fCachedUse24HourClock(other.fCachedUse24HourClock), 203 fExplicitNumericFormat(other.fExplicitNumericFormat), 204 fExplicitMonetaryFormat(other.fExplicitMonetaryFormat), 205 fExplicitUse24HourClock(other.fExplicitUse24HourClock), 206 fUseStringsFromPreferredLanguage(other.fUseStringsFromPreferredLanguage), 207 fICULocale(new icu::Locale(*other.fICULocale)) 208 { 209 for (int s = 0; s < B_DATE_FORMAT_STYLE_COUNT; ++s) { 210 fCachedDateFormats[s] = other.fCachedDateFormats[s]; 211 fExplicitDateFormats[s] = other.fExplicitDateFormats[s]; 212 213 for (int t = 0; t < B_TIME_FORMAT_STYLE_COUNT; ++t) { 214 fCachedDateTimeFormats[s][t] = other.fCachedDateFormats[s][t]; 215 fExplicitDateFormats[s][t] = other.fExplicitDateFormats[s][t]; 216 } 217 } 218 for (int s = 0; s < B_TIME_FORMAT_STYLE_COUNT; ++s) { 219 fCachedTimeFormats[s] = other.fCachedTimeFormats[s]; 220 fExplicitTimeFormats[s] = other.fExplicitTimeFormats[s]; 221 } 222 } 223 224 225 BFormattingConventions::BFormattingConventions(const BMessage* archive) 226 : 227 fCachedUse24HourClock(CLOCK_HOURS_UNSET), 228 fExplicitUse24HourClock(CLOCK_HOURS_UNSET), 229 fUseStringsFromPreferredLanguage(false) 230 { 231 BString conventionsID; 232 status_t status = archive->FindString("conventions", &conventionsID); 233 fICULocale = new icu::Locale(conventionsID); 234 235 for (int s = 0; s < B_DATE_FORMAT_STYLE_COUNT && status == B_OK; ++s) { 236 BString format; 237 status = archive->FindString("dateFormat", s, &format); 238 if (status == B_OK) 239 fExplicitDateFormats[s] = format; 240 241 status = archive->FindString("timeFormat", s, &format); 242 if (status == B_OK) 243 fExplicitTimeFormats[s] = format; 244 } 245 246 if (status == B_OK) { 247 int8 use24HourClock; 248 status = archive->FindInt8("use24HourClock", &use24HourClock); 249 if (status == B_OK) 250 fExplicitUse24HourClock = use24HourClock; 251 } 252 if (status == B_OK) { 253 bool useStringsFromPreferredLanguage; 254 status = archive->FindBool("useStringsFromPreferredLanguage", 255 &useStringsFromPreferredLanguage); 256 if (status == B_OK) 257 fUseStringsFromPreferredLanguage = useStringsFromPreferredLanguage; 258 } 259 } 260 261 262 BFormattingConventions& 263 BFormattingConventions::operator=(const BFormattingConventions& other) 264 { 265 if (this == &other) 266 return *this; 267 268 for (int s = 0; s < B_DATE_FORMAT_STYLE_COUNT; ++s) { 269 fCachedDateFormats[s] = other.fCachedDateFormats[s]; 270 fExplicitDateFormats[s] = other.fExplicitDateFormats[s]; 271 for (int t = 0; t < B_TIME_FORMAT_STYLE_COUNT; ++t) { 272 fCachedDateTimeFormats[s][t] = other.fCachedDateTimeFormats[s][t]; 273 fExplicitDateTimeFormats[s][t] 274 = other.fExplicitDateTimeFormats[s][t]; 275 } 276 } 277 for (int s = 0; s < B_TIME_FORMAT_STYLE_COUNT; ++s) { 278 fCachedTimeFormats[s] = other.fCachedTimeFormats[s]; 279 fExplicitTimeFormats[s] = other.fExplicitTimeFormats[s]; 280 } 281 fCachedNumericFormat = other.fCachedNumericFormat; 282 fCachedMonetaryFormat = other.fCachedMonetaryFormat; 283 fCachedUse24HourClock = other.fCachedUse24HourClock; 284 285 fExplicitNumericFormat = other.fExplicitNumericFormat; 286 fExplicitMonetaryFormat = other.fExplicitMonetaryFormat; 287 fExplicitUse24HourClock = other.fExplicitUse24HourClock; 288 289 fUseStringsFromPreferredLanguage = other.fUseStringsFromPreferredLanguage; 290 291 *fICULocale = *other.fICULocale; 292 293 return *this; 294 } 295 296 297 BFormattingConventions::~BFormattingConventions() 298 { 299 delete fICULocale; 300 } 301 302 303 bool 304 BFormattingConventions::operator==(const BFormattingConventions& other) const 305 { 306 if (this == &other) 307 return true; 308 309 for (int s = 0; s < B_DATE_FORMAT_STYLE_COUNT; ++s) { 310 if (fExplicitDateFormats[s] != other.fExplicitDateFormats[s]) 311 return false; 312 } 313 for (int s = 0; s < B_TIME_FORMAT_STYLE_COUNT; ++s) { 314 if (fExplicitTimeFormats[s] != other.fExplicitTimeFormats[s]) 315 return false; 316 } 317 318 return fExplicitNumericFormat == other.fExplicitNumericFormat 319 && fExplicitMonetaryFormat == other.fExplicitMonetaryFormat 320 && fExplicitUse24HourClock == other.fExplicitUse24HourClock 321 && fUseStringsFromPreferredLanguage 322 == other.fUseStringsFromPreferredLanguage 323 && *fICULocale == *other.fICULocale; 324 } 325 326 327 bool 328 BFormattingConventions::operator!=(const BFormattingConventions& other) const 329 { 330 return !(*this == other); 331 } 332 333 334 const char* 335 BFormattingConventions::ID() const 336 { 337 return fICULocale->getName(); 338 } 339 340 341 const char* 342 BFormattingConventions::LanguageCode() const 343 { 344 return fICULocale->getLanguage(); 345 } 346 347 348 const char* 349 BFormattingConventions::CountryCode() const 350 { 351 const char* country = fICULocale->getCountry(); 352 if (country == NULL || country[0] == '\0') 353 return NULL; 354 355 return country; 356 } 357 358 359 bool 360 BFormattingConventions::AreCountrySpecific() const 361 { 362 return CountryCode() != NULL; 363 } 364 365 366 status_t 367 BFormattingConventions::GetNativeName(BString& name) const 368 { 369 UnicodeString string; 370 fICULocale->getDisplayName(*fICULocale, string); 371 string.toTitle(NULL, *fICULocale); 372 373 name.Truncate(0); 374 BStringByteSink converter(&name); 375 string.toUTF8(converter); 376 377 return B_OK; 378 } 379 380 381 status_t 382 BFormattingConventions::GetName(BString& name, 383 const BLanguage* displayLanguage) const 384 { 385 BString displayLanguageID; 386 if (displayLanguage == NULL) { 387 BLanguage defaultLanguage; 388 BLocale::Default()->GetLanguage(&defaultLanguage); 389 displayLanguageID = defaultLanguage.Code(); 390 } else { 391 displayLanguageID = displayLanguage->Code(); 392 } 393 394 UnicodeString uString; 395 fICULocale->getDisplayName(Locale(displayLanguageID.String()), uString); 396 name.Truncate(0); 397 BStringByteSink stringConverter(&name); 398 uString.toUTF8(stringConverter); 399 400 return B_OK; 401 } 402 403 404 BMeasurementKind 405 BFormattingConventions::MeasurementKind() const 406 { 407 UErrorCode error = U_ZERO_ERROR; 408 switch (ulocdata_getMeasurementSystem(ID(), &error)) { 409 case UMS_US: 410 return B_US; 411 case UMS_SI: 412 default: 413 return B_METRIC; 414 } 415 } 416 417 418 status_t 419 BFormattingConventions::GetDateFormat(BDateFormatStyle style, 420 BString& outFormat) const 421 { 422 if (style < 0 || style >= B_DATE_FORMAT_STYLE_COUNT) 423 return B_BAD_VALUE; 424 425 outFormat = fExplicitDateFormats[style].Length() 426 ? fExplicitDateFormats[style] 427 : fCachedDateFormats[style]; 428 429 if (outFormat.Length() > 0) 430 return B_OK; 431 432 ObjectDeleter<DateFormat> dateFormatter( 433 DateFormat::createDateInstance((DateFormat::EStyle)style, *fICULocale)); 434 if (dateFormatter.Get() == NULL) 435 return B_NO_MEMORY; 436 437 SimpleDateFormat* dateFormatterImpl 438 = static_cast<SimpleDateFormat*>(dateFormatter.Get()); 439 440 UnicodeString icuString; 441 dateFormatterImpl->toPattern(icuString); 442 BStringByteSink stringConverter(&outFormat); 443 icuString.toUTF8(stringConverter); 444 445 fCachedDateFormats[style] = outFormat; 446 447 return B_OK; 448 } 449 450 451 status_t 452 BFormattingConventions::GetTimeFormat(BTimeFormatStyle style, 453 BString& outFormat) const 454 { 455 if (style < 0 || style >= B_TIME_FORMAT_STYLE_COUNT) 456 return B_BAD_VALUE; 457 458 outFormat = fExplicitTimeFormats[style].Length() 459 ? fExplicitTimeFormats[style] 460 : fCachedTimeFormats[style]; 461 462 if (outFormat.Length() > 0) 463 return B_OK; 464 465 ObjectDeleter<DateFormat> timeFormatter( 466 DateFormat::createTimeInstance((DateFormat::EStyle)style, *fICULocale)); 467 if (timeFormatter.Get() == NULL) 468 return B_NO_MEMORY; 469 470 SimpleDateFormat* timeFormatterImpl 471 = static_cast<SimpleDateFormat*>(timeFormatter.Get()); 472 473 UnicodeString icuString; 474 timeFormatterImpl->toPattern(icuString); 475 BStringByteSink stringConverter(&outFormat); 476 icuString.toUTF8(stringConverter); 477 478 int8 use24HourClock = fExplicitUse24HourClock != CLOCK_HOURS_UNSET 479 ? fExplicitUse24HourClock : fCachedUse24HourClock; 480 if (use24HourClock != CLOCK_HOURS_UNSET) { 481 // adjust to 12/24-hour clock as requested 482 bool localeUses24HourClock = !FormatUsesAmPm(outFormat); 483 if (localeUses24HourClock) { 484 if (use24HourClock == CLOCK_HOURS_12) 485 CoerceFormatTo12HourClock(outFormat); 486 } else { 487 if (use24HourClock == CLOCK_HOURS_24) 488 CoerceFormatTo24HourClock(outFormat); 489 } 490 } 491 492 if (style != B_FULL_TIME_FORMAT) { 493 // use abbreviated timezone in short timezone format 494 CoerceFormatToAbbreviatedTimezone(outFormat); 495 } 496 497 fCachedTimeFormats[style] = outFormat; 498 499 return B_OK; 500 } 501 502 503 status_t 504 BFormattingConventions::GetDateTimeFormat(BDateFormatStyle dateStyle, 505 BTimeFormatStyle timeStyle, BString& outFormat) const 506 { 507 if (dateStyle < 0 || dateStyle >= B_DATE_FORMAT_STYLE_COUNT) 508 return B_BAD_VALUE; 509 510 if (timeStyle < 0 || timeStyle >= B_TIME_FORMAT_STYLE_COUNT) 511 return B_BAD_VALUE; 512 513 outFormat = fExplicitDateTimeFormats[dateStyle][timeStyle].Length() 514 ? fExplicitDateTimeFormats[dateStyle][timeStyle] 515 : fCachedDateTimeFormats[dateStyle][timeStyle]; 516 517 if (outFormat.Length() > 0) 518 return B_OK; 519 520 ObjectDeleter<DateFormat> dateFormatter( 521 DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle, 522 (DateFormat::EStyle)timeStyle, *fICULocale)); 523 if (dateFormatter.Get() == NULL) 524 return B_NO_MEMORY; 525 526 SimpleDateFormat* dateFormatterImpl 527 = static_cast<SimpleDateFormat*>(dateFormatter.Get()); 528 529 UnicodeString icuString; 530 dateFormatterImpl->toPattern(icuString); 531 BStringByteSink stringConverter(&outFormat); 532 icuString.toUTF8(stringConverter); 533 534 fCachedDateTimeFormats[dateStyle][timeStyle] = outFormat; 535 536 return B_OK; 537 } 538 539 540 status_t 541 BFormattingConventions::GetNumericFormat(BString& outFormat) const 542 { 543 // TODO! 544 return B_UNSUPPORTED; 545 } 546 547 548 status_t 549 BFormattingConventions::GetMonetaryFormat(BString& outFormat) const 550 { 551 // TODO! 552 return B_UNSUPPORTED; 553 } 554 555 556 void 557 BFormattingConventions::SetExplicitDateFormat(BDateFormatStyle style, 558 const BString& format) 559 { 560 fExplicitDateFormats[style] = format; 561 } 562 563 564 void 565 BFormattingConventions::SetExplicitTimeFormat(BTimeFormatStyle style, 566 const BString& format) 567 { 568 fExplicitTimeFormats[style] = format; 569 } 570 571 572 void 573 BFormattingConventions::SetExplicitDateTimeFormat(BDateFormatStyle dateStyle, 574 BTimeFormatStyle timeStyle, const BString& format) 575 { 576 fExplicitDateTimeFormats[dateStyle][timeStyle] = format; 577 } 578 579 580 void 581 BFormattingConventions::SetExplicitNumericFormat(const BString& format) 582 { 583 fExplicitNumericFormat = format; 584 } 585 586 587 void 588 BFormattingConventions::SetExplicitMonetaryFormat(const BString& format) 589 { 590 fExplicitMonetaryFormat = format; 591 } 592 593 594 bool 595 BFormattingConventions::UseStringsFromPreferredLanguage() const 596 { 597 return fUseStringsFromPreferredLanguage; 598 } 599 600 601 void 602 BFormattingConventions::SetUseStringsFromPreferredLanguage(bool value) 603 { 604 fUseStringsFromPreferredLanguage = value; 605 } 606 607 608 bool 609 BFormattingConventions::Use24HourClock() const 610 { 611 int8 use24HourClock = fExplicitUse24HourClock != CLOCK_HOURS_UNSET 612 ? fExplicitUse24HourClock : fCachedUse24HourClock; 613 614 if (use24HourClock == CLOCK_HOURS_UNSET) { 615 BString format; 616 GetTimeFormat(B_MEDIUM_TIME_FORMAT, format); 617 fCachedUse24HourClock 618 = FormatUsesAmPm(format) ? CLOCK_HOURS_12 : CLOCK_HOURS_24; 619 return fCachedUse24HourClock == CLOCK_HOURS_24; 620 } 621 622 return fExplicitUse24HourClock == CLOCK_HOURS_24; 623 } 624 625 626 void 627 BFormattingConventions::SetExplicitUse24HourClock(bool value) 628 { 629 int8 newUse24HourClock = value ? CLOCK_HOURS_24 : CLOCK_HOURS_12; 630 if (fExplicitUse24HourClock == newUse24HourClock) 631 return; 632 633 fExplicitUse24HourClock = newUse24HourClock; 634 635 for (int s = 0; s < B_TIME_FORMAT_STYLE_COUNT; ++s) 636 fCachedTimeFormats[s].Truncate(0); 637 } 638 639 640 void 641 BFormattingConventions::UnsetExplicitUse24HourClock() 642 { 643 fExplicitUse24HourClock = CLOCK_HOURS_UNSET; 644 645 for (int s = 0; s < B_TIME_FORMAT_STYLE_COUNT; ++s) 646 fCachedTimeFormats[s].Truncate(0); 647 } 648 649 650 status_t 651 BFormattingConventions::Archive(BMessage* archive, bool deep) const 652 { 653 status_t status = archive->AddString("conventions", fICULocale->getName()); 654 for (int s = 0; s < B_DATE_FORMAT_STYLE_COUNT && status == B_OK; ++s) { 655 status = archive->AddString("dateFormat", fExplicitDateFormats[s]); 656 if (status == B_OK) 657 status = archive->AddString("timeFormat", fExplicitTimeFormats[s]); 658 } 659 if (status == B_OK) 660 status = archive->AddInt8("use24HourClock", fExplicitUse24HourClock); 661 if (status == B_OK) { 662 status = archive->AddBool("useStringsFromPreferredLanguage", 663 fUseStringsFromPreferredLanguage); 664 } 665 666 return status; 667 } 668