src/preferences/time/ZoneView.cpp

   1 /*
   2  * Copyright 2004-2013 Haiku, Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Mike Berg, mike@berg-net.us
   7  *              Adrien Destugues, pulkomandy@pulkomandy.ath.cx
   8  *              Julun, host.haiku@gmx.de
   9  *              Hamish Morrison, hamish@lavabit.com
  10  *              Philippe Saint-Pierre, stpere@gmail.com
  11  *              John Scipione, jscipione@gmail.com
  12  *              Oliver Tappe, zooey@hirschkaefer.de
  13  */
  14
  15
  16 #include <unicode/uversion.h>
  17 #include "ZoneView.h"
  18
  19 #include <stdlib.h>
  20 #include <syscalls.h>
  21
  22 #include <map>
  23 #include <new>
  24 #include <vector>
  25
  26 #include <AutoDeleter.h>
  27 #include <Button.h>
  28 #include <Catalog.h>
  29 #include <Collator.h>
  30 #include <ControlLook.h>
  31 #include <Country.h>
  32 #include <Directory.h>
  33 #include <Entry.h>
  34 #include <File.h>
  35 #include <FindDirectory.h>
  36 #include <ListItem.h>
  37 #include <Locale.h>
  38 #include <MutableLocaleRoster.h>
  39 #include <OutlineListView.h>
  40 #include <Path.h>
  41 #include <RadioButton.h>
  42 #include <ScrollView.h>
  43 #include <StorageDefs.h>
  44 #include <String.h>
  45 #include <StringView.h>
  46 #include <TimeZone.h>
  47 #include <View.h>
  48 #include <Window.h>
  49
  50 #include <unicode/datefmt.h>
  51 #include <unicode/utmscale.h>
  52 #include <ICUWrapper.h>
  53
  54 #include "TimeMessages.h"
  55 #include "TimeZoneListItem.h"
  56 #include "TimeZoneListView.h"
  57 #include "TZDisplay.h"
  58
  59
  60 #undef B_TRANSLATION_CONTEXT
  61 #define B_TRANSLATION_CONTEXT "Time"
  62
  63
  64 using BPrivate::MutableLocaleRoster;
  65 using BPrivate::ObjectDeleter;
  66
  67
  68 struct TimeZoneItemLess {
  69         bool operator()(const BString& first, const BString& second)
  70         {
  71                 // sort anything starting with '<' behind anything else
  72                 if (first.ByteAt(0) == '<') {
  73                         if (second.ByteAt(0) != '<')
  74                                 return false;
  75                 } else if (second.ByteAt(0) == '<')
  76                         return true;
  77                 return fCollator.Compare(first.String(), second.String()) < 0;
  78         }
  79 private:
  80         BCollator fCollator;
  81 };
  82
  83
  84
  85 TimeZoneView::TimeZoneView(const char* name)
  86         :
  87         BGroupView(name, B_HORIZONTAL, B_USE_DEFAULT_SPACING),
  88         fGmtTime(NULL),
  89         fUseGmtTime(false),
  90         fCurrentZoneItem(NULL),
  91         fOldZoneItem(NULL),
  92         fInitialized(false)
  93 {
  94         _ReadRTCSettings();
  95         _InitView();
  96 }
  97
  98
  99 bool
 100 TimeZoneView::CheckCanRevert()
 101 {
 102         // check GMT vs Local setting
 103         bool enable = fUseGmtTime != fOldUseGmtTime;
 104
 105         return enable || fCurrentZoneItem != fOldZoneItem;
 106 }
 107
 108
 109 TimeZoneView::~TimeZoneView()
 110 {
 111         _WriteRTCSettings();
 112 }
 113
 114
 115 void
 116 TimeZoneView::AttachedToWindow()
 117 {
 118         BView::AttachedToWindow();
 119         if (Parent())
 120                 SetViewColor(Parent()->ViewColor());
 121
 122         if (!fInitialized) {
 123                 fInitialized = true;
 124
 125                 fSetZone->SetTarget(this);
 126                 fZoneList->SetTarget(this);
 127         }
 128 }
 129
 130
 131 void
 132 TimeZoneView::DoLayout()
 133 {
 134         BView::DoLayout();
 135         if (fCurrentZoneItem != NULL) {
 136                 fZoneList->Select(fZoneList->IndexOf(fCurrentZoneItem));
 137                 fCurrent->SetText(fCurrentZoneItem->Text());
 138                 fZoneList->ScrollToSelection();
 139         }
 140 }
 141
 142
 143 void
 144 TimeZoneView::MessageReceived(BMessage* message)
 145 {
 146         switch (message->what) {
 147                 case B_OBSERVER_NOTICE_CHANGE:
 148                 {
 149                         int32 change;
 150                         message->FindInt32(B_OBSERVE_WHAT_CHANGE, &change);
 151                         switch(change) {
 152                                 case H_TM_CHANGED:
 153                                         _UpdateDateTime(message);
 154                                         break;
 155
 156                                 default:
 157                                         BView::MessageReceived(message);
 158                                         break;
 159                         }
 160                         break;
 161                 }
 162
 163                 case H_CITY_CHANGED:
 164                         _UpdatePreview();
 165                         break;
 166
 167                 case H_SET_TIME_ZONE:
 168                 {
 169                         _SetSystemTimeZone();
 170                         break;
 171                 }
 172
 173                 case kMsgRevert:
 174                         _Revert();
 175                         break;
 176
 177                 case kRTCUpdate:
 178                         fUseGmtTime = fGmtTime->Value() == B_CONTROL_ON;
 179                         _UpdateGmtSettings();
 180                         _UpdateCurrent();
 181                         _UpdatePreview();
 182                         break;
 183
 184                 default:
 185                         BGroupView::MessageReceived(message);
 186                         break;
 187         }
 188 }
 189
 190
 191 void
 192 TimeZoneView::_UpdateDateTime(BMessage* message)
 193 {
 194         // only need to update once every minute
 195         int32 minute;
 196         if (message->FindInt32("minute", &minute) == B_OK) {
 197                 if (fLastUpdateMinute != minute) {
 198                         _UpdateCurrent();
 199                         _UpdatePreview();
 200
 201                         fLastUpdateMinute = minute;
 202                 }
 203         }
 204 }
 205
 206
 207 void
 208 TimeZoneView::_InitView()
 209 {
 210         fZoneList = new TimeZoneListView();
 211         fZoneList->SetSelectionMessage(new BMessage(H_CITY_CHANGED));
 212         fZoneList->SetInvocationMessage(new BMessage(H_SET_TIME_ZONE));
 213         _BuildZoneMenu();
 214         BScrollView* scrollList = new BScrollView("scrollList", fZoneList,
 215                 B_FRAME_EVENTS | B_WILL_DRAW, false, true);
 216         scrollList->SetExplicitMinSize(BSize(200, 0));
 217
 218         fCurrent = new TTZDisplay("currentTime", B_TRANSLATE("Current time:"));
 219         fPreview = new TTZDisplay("previewTime", B_TRANSLATE("Preview time:"));
 220
 221         fSetZone = new BButton("setTimeZone", B_TRANSLATE("Set time zone"),
 222                 new BMessage(H_SET_TIME_ZONE));
 223         fSetZone->SetEnabled(false);
 224         fSetZone->SetExplicitAlignment(
 225                 BAlignment(B_ALIGN_RIGHT, B_ALIGN_BOTTOM));
 226
 227         fLocalTime = new BRadioButton("localTime",
 228                 B_TRANSLATE("Local time (Windows compatible)"),
 229                         new BMessage(kRTCUpdate));
 230         fGmtTime = new BRadioButton("greenwichMeanTime",
 231                 B_TRANSLATE("GMT (UNIX compatible)"), new BMessage(kRTCUpdate));
 232
 233         if (fUseGmtTime)
 234                 fGmtTime->SetValue(B_CONTROL_ON);
 235         else
 236                 fLocalTime->SetValue(B_CONTROL_ON);
 237         _ShowOrHidePreview();
 238         fOldUseGmtTime = fUseGmtTime;
 239
 240         const float kIndentSpacing
 241                 = be_control_look->DefaultItemSpacing() * 2;
 242         BLayoutBuilder::Group<>(this)
 243                 .Add(scrollList)
 244                 .AddGroup(B_VERTICAL, 0)
 245                         .Add(new BStringView("clockSetTo",
 246                                 B_TRANSLATE("Hardware clock set to:")))
 247                         .AddGroup(B_VERTICAL, 0)
 248                                 .Add(fLocalTime)
 249                                 .Add(fGmtTime)
 250                                 .SetInsets(kIndentSpacing, 0, 0, 0)
 251                         .End()
 252                         .AddGlue()
 253                         .AddGroup(B_VERTICAL, B_USE_DEFAULT_SPACING)
 254                                 .Add(fCurrent)
 255                                 .Add(fPreview)
 256                         .End()
 257                         .Add(fSetZone)
 258                 .End()
 259                 .SetInsets(B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING,
 260                         B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING);
 261 }
 262
 263
 264 void
 265 TimeZoneView::_BuildZoneMenu()
 266 {
 267         BTimeZone defaultTimeZone;
 268         BLocaleRoster::Default()->GetDefaultTimeZone(&defaultTimeZone);
 269
 270         BLanguage language;
 271         BLocale::Default()->GetLanguage(&language);
 272
 273         // Group timezones by regions, but filter out unwanted (duplicate) regions
 274         // and add an additional region with generic GMT-offset timezones at the end
 275         typedef std::map<BString, TimeZoneListItem*, TimeZoneItemLess> ZoneItemMap;
 276         ZoneItemMap zoneItemMap;
 277         const char* kOtherRegion = B_TRANSLATE_MARK("<Other>");
 278         const char* kSupportedRegions[] = {
 279                 B_TRANSLATE_MARK("Africa"),             B_TRANSLATE_MARK("America"),
 280                 B_TRANSLATE_MARK("Antarctica"), B_TRANSLATE_MARK("Arctic"),
 281                 B_TRANSLATE_MARK("Asia"),               B_TRANSLATE_MARK("Atlantic"),
 282                 B_TRANSLATE_MARK("Australia"),  B_TRANSLATE_MARK("Europe"),
 283                 B_TRANSLATE_MARK("Indian"),             B_TRANSLATE_MARK("Pacific"),
 284                 kOtherRegion,
 285                 NULL
 286         };
 287
 288         // Since the zone-map contains translated country-names (we get those from
 289         // ICU), we need to use translated region names in the zone-map, too:
 290         typedef std::map<BString, BString> TranslatedRegionMap;
 291         TranslatedRegionMap regionMap;
 292         for (const char** region = kSupportedRegions; *region != NULL; ++region) {
 293                 BString translatedRegion = B_TRANSLATE_NOCOLLECT(*region);
 294                 regionMap[*region] = translatedRegion;
 295
 296                 TimeZoneListItem* regionItem
 297                         = new TimeZoneListItem(translatedRegion, NULL, NULL);
 298                 regionItem->SetOutlineLevel(0);
 299                 zoneItemMap[translatedRegion] = regionItem;
 300         }
 301
 302         // Get all time zones
 303         BMessage zoneList;
 304         BLocaleRoster::Default()->GetAvailableTimeZonesWithRegionInfo(&zoneList);
 305
 306         typedef std::map<BString, std::vector<const char*> > ZonesByCountyMap;
 307         ZonesByCountyMap zonesByCountryMap;
 308         const char* zoneID;
 309         BString timeZoneCode;
 310         for (int tz = 0; zoneList.FindString("timeZone", tz, &zoneID) == B_OK
 311                         && zoneList.FindString("region", tz, &timeZoneCode) == B_OK; tz++) {
 312                 // From the global ("001") timezones, we only accept the generic GMT
 313                 // timezones, as all the other world-zones are duplicates of others.
 314                 if (timeZoneCode == "001" && strncmp(zoneID, "Etc/GMT", 7) != 0)
 315                         continue;
 316                 zonesByCountryMap[timeZoneCode].push_back(zoneID);
 317         }
 318
 319         ZonesByCountyMap::const_iterator countryIter = zonesByCountryMap.begin();
 320         for (; countryIter != zonesByCountryMap.end(); ++countryIter) {
 321                 const char* countryCode = countryIter->first.String();
 322                 if (countryCode == NULL)
 323                         continue;
 324
 325                 size_t zoneCountInCountry = countryIter->second.size();
 326                 for (size_t tz = 0; tz < zoneCountInCountry; tz++) {
 327                         BString zoneID(countryIter->second[tz]);
 328                         BTimeZone* timeZone
 329                                 = new(std::nothrow) BTimeZone(zoneID, &language);
 330                         if (timeZone == NULL)
 331                                 continue;
 332
 333                         int32 slashPos = zoneID.FindFirst('/');
 334                         BString region(zoneID, slashPos);
 335                         if (region == "Etc")
 336                                 region = kOtherRegion;
 337
 338                         // just accept timezones from our supported regions, others are
 339                         // aliases and would just make the list even longer
 340                         TranslatedRegionMap::iterator regionIter = regionMap.find(region);
 341                         if (regionIter == regionMap.end())
 342                                 continue;
 343
 344                         BString fullCountryID = regionIter->second;
 345                         BCountry* country = new(std::nothrow) BCountry(countryCode);
 346                         if (country == NULL)
 347                                 continue;
 348
 349                         BString countryName;
 350                         country->GetName(countryName);
 351                         bool hasUsedCountry = false;
 352                         bool countryIsRegion = countryName == regionIter->second
 353                                 || region == kOtherRegion;
 354                         if (!countryIsRegion)
 355                                 fullCountryID << "/" << countryName;
 356
 357                         BString timeZoneName;
 358                         BString fullZoneID = fullCountryID;
 359                         if (zoneCountInCountry > 1) {
 360                                 // we can't use the country name as timezone name, since there
 361                                 // are more than one timezones in this country - fetch the
 362                                 // localized name of the timezone and use that
 363                                 timeZoneName = timeZone->Name();
 364                                 int32 openParenthesisPos = timeZoneName.FindFirst('(');
 365                                 if (openParenthesisPos >= 0) {
 366                                         timeZoneName.Remove(0, openParenthesisPos + 1);
 367                                         int32 closeParenthesisPos = timeZoneName.FindLast(')');
 368                                         if (closeParenthesisPos >= 0)
 369                                                 timeZoneName.Truncate(closeParenthesisPos);
 370                                 }
 371                                 fullZoneID << "/" << timeZoneName;
 372                         } else {
 373                                 timeZoneName = countryName;
 374                                 fullZoneID << "/" << zoneID;
 375                         }
 376
 377                         // skip duplicates
 378                         ZoneItemMap::iterator zoneIter = zoneItemMap.find(fullZoneID);
 379                         if (zoneIter != zoneItemMap.end()) {
 380                                 delete timeZone;
 381                                 continue;
 382                         }
 383
 384                         TimeZoneListItem* countryItem = NULL;
 385                         TimeZoneListItem* zoneItem = NULL;
 386                         if (zoneCountInCountry > 1) {
 387                                 ZoneItemMap::iterator countryIter
 388                                         = zoneItemMap.find(fullCountryID);
 389                                 if (countryIter == zoneItemMap.end()) {
 390                                         countryItem = new TimeZoneListItem(countryName.String(),
 391                                                 country, NULL);
 392                                         countryItem->SetOutlineLevel(1);
 393                                         zoneItemMap[fullCountryID] = countryItem;
 394                                         hasUsedCountry = true;
 395                                 } else
 396                                         countryItem = countryIter->second;
 397
 398                                 zoneItem = new TimeZoneListItem(timeZoneName.String(),
 399                                         NULL, timeZone);
 400                                 zoneItem->SetOutlineLevel(countryIsRegion ? 1 : 2);
 401                         } else {
 402                                 zoneItem = new TimeZoneListItem(timeZoneName.String(),
 403                                         country, timeZone);
 404                                 zoneItem->SetOutlineLevel(1);
 405                                 hasUsedCountry = true;
 406                         }
 407                         zoneItemMap[fullZoneID] = zoneItem;
 408
 409                         if (timeZone->ID() == defaultTimeZone.ID()) {
 410                                 fCurrentZoneItem = zoneItem;
 411                                 if (countryItem != NULL)
 412                                         countryItem->SetExpanded(true);
 413
 414                                 ZoneItemMap::iterator regionItemIter
 415                                         = zoneItemMap.find(regionIter->second);
 416                                 if (regionItemIter != zoneItemMap.end())
 417                                         regionItemIter->second->SetExpanded(true);
 418                         }
 419
 420                         if (!hasUsedCountry)
 421                                 delete country;
 422                 }
 423         }
 424
 425         fOldZoneItem = fCurrentZoneItem;
 426
 427         ZoneItemMap::iterator zoneIter;
 428         bool lastWasCountryItem = false;
 429         TimeZoneListItem* currentItem = NULL;
 430         for (zoneIter = zoneItemMap.begin(); zoneIter != zoneItemMap.end();
 431                         ++zoneIter) {
 432                 if (zoneIter->second->OutlineLevel() == 2 && lastWasCountryItem) {
 433                         // Some countries (e.g. Spain and Chile) have their timezones
 434                         // spread across different regions. As a result, there might still
 435                         // be country items with only one timezone below them. We manually
 436                         // filter those country items here.
 437                         ZoneItemMap::iterator next = zoneIter;
 438                         ++next;
 439                         if (next != zoneItemMap.end()
 440                                 && next->second->OutlineLevel() != 2) {
 441                                 fZoneList->RemoveItem(currentItem);
 442                                 zoneIter->second->SetText(currentItem->Text());
 443                                 zoneIter->second->SetCountry(currentItem->HasCountry()
 444                                         ? new(std::nothrow) BCountry(currentItem->Country())
 445                                         : NULL);
 446                                 zoneIter->second->SetTimeZone(currentItem->HasTimeZone()
 447                                         ? new(std::nothrow) BTimeZone(currentItem->TimeZone())
 448                                         : NULL);
 449                                 zoneIter->second->SetOutlineLevel(1);
 450                                 delete currentItem;
 451                         }
 452                 }
 453
 454                 fZoneList->AddItem(zoneIter->second);
 455                 if (zoneIter->second->OutlineLevel() == 1) {
 456                         lastWasCountryItem = true;
 457                         currentItem = zoneIter->second;
 458                 } else
 459                         lastWasCountryItem = false;
 460         }
 461 }
 462
 463
 464 void
 465 TimeZoneView::_Revert()
 466 {
 467         fCurrentZoneItem = fOldZoneItem;
 468
 469         if (fCurrentZoneItem != NULL) {
 470                 int32 currentZoneIndex = fZoneList->IndexOf(fCurrentZoneItem);
 471                 fZoneList->Select(currentZoneIndex);
 472         } else
 473                 fZoneList->DeselectAll();
 474         fZoneList->ScrollToSelection();
 475
 476         fUseGmtTime = fOldUseGmtTime;
 477         if (fUseGmtTime)
 478                 fGmtTime->SetValue(B_CONTROL_ON);
 479         else
 480                 fLocalTime->SetValue(B_CONTROL_ON);
 481         _ShowOrHidePreview();
 482
 483         _UpdateGmtSettings();
 484         _SetSystemTimeZone();
 485         _UpdatePreview();
 486         _UpdateCurrent();
 487 }
 488
 489
 490 void
 491 TimeZoneView::_UpdatePreview()
 492 {
 493         int32 selection = fZoneList->CurrentSelection();
 494         TimeZoneListItem* item
 495                 = selection < 0
 496                         ? NULL
 497                         : static_cast<TimeZoneListItem*>(fZoneList->ItemAt(selection));
 498
 499         if (item == NULL || !item->HasTimeZone()) {
 500                 fPreview->SetText("");
 501                 fPreview->SetTime("");
 502                 return;
 503         }
 504
 505         BString timeString = _FormatTime(item->TimeZone());
 506         fPreview->SetText(item->Text());
 507         fPreview->SetTime(timeString.String());
 508
 509         fSetZone->SetEnabled((strcmp(fCurrent->Text(), item->Text()) != 0));
 510 }
 511
 512
 513 void
 514 TimeZoneView::_UpdateCurrent()
 515 {
 516         if (fCurrentZoneItem == NULL)
 517                 return;
 518
 519         BString timeString = _FormatTime(fCurrentZoneItem->TimeZone());
 520         fCurrent->SetText(fCurrentZoneItem->Text());
 521         fCurrent->SetTime(timeString.String());
 522 }
 523
 524
 525 void
 526 TimeZoneView::_SetSystemTimeZone()
 527 {
 528         /*      Set system timezone for all different API levels. How to do this?
 529          *      1) tell locale-roster about new default timezone
 530          *      2) tell kernel about new timezone offset
 531          */
 532
 533         int32 selection = fZoneList->CurrentSelection();
 534         if (selection < 0)
 535                 return;
 536
 537         TimeZoneListItem* item
 538                 = static_cast<TimeZoneListItem*>(fZoneList->ItemAt(selection));
 539         if (item == NULL || !item->HasTimeZone())
 540                 return;
 541
 542         fCurrentZoneItem = item;
 543         const BTimeZone& timeZone = item->TimeZone();
 544
 545         MutableLocaleRoster::Default()->SetDefaultTimeZone(timeZone);
 546
 547         _kern_set_timezone(timeZone.OffsetFromGMT(), timeZone.ID().String(),
 548                 timeZone.ID().Length());
 549
 550         fSetZone->SetEnabled(false);
 551         fLastUpdateMinute = -1;
 552                 // just to trigger updating immediately
 553 }
 554
 555
 556 BString
 557 TimeZoneView::_FormatTime(const BTimeZone& timeZone)
 558 {
 559         BString result;
 560
 561         time_t now = time(NULL);
 562         bool rtcIsGMT;
 563         _kern_get_real_time_clock_is_gmt(&rtcIsGMT);
 564         if (!rtcIsGMT) {
 565                 int32 currentOffset
 566                         = fCurrentZoneItem != NULL && fCurrentZoneItem->HasTimeZone()
 567                                 ? fCurrentZoneItem->OffsetFromGMT()
 568                                 : 0;
 569                 now -= timeZone.OffsetFromGMT() - currentOffset;
 570         }
 571         fTimeFormat.Format(result, now, B_SHORT_TIME_FORMAT, &timeZone);
 572
 573         return result;
 574 }
 575
 576
 577 void
 578 TimeZoneView::_ReadRTCSettings()
 579 {
 580         BPath path;
 581         if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
 582                 return;
 583
 584         path.Append("RTC_time_settings");
 585
 586         BEntry entry(path.Path());
 587         if (entry.Exists()) {
 588                 BFile file(&entry, B_READ_ONLY);
 589                 if (file.InitCheck() == B_OK) {
 590                         char buffer[6];
 591                         file.Read(buffer, 6);
 592                         if (strncmp(buffer, "gmt", 3) == 0)
 593                                 fUseGmtTime = true;
 594                 }
 595         }
 596 }
 597
 598
 599 void
 600 TimeZoneView::_WriteRTCSettings()
 601 {
 602         BPath path;
 603         if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, true) != B_OK)
 604                 return;
 605
 606         path.Append("RTC_time_settings");
 607
 608         BFile file(path.Path(), B_CREATE_FILE | B_ERASE_FILE | B_WRITE_ONLY);
 609         if (file.InitCheck() == B_OK) {
 610                 if (fUseGmtTime)
 611                         file.Write("gmt", 3);
 612                 else
 613                         file.Write("local", 5);
 614         }
 615 }
 616
 617
 618 void
 619 TimeZoneView::_UpdateGmtSettings()
 620 {
 621         _WriteRTCSettings();
 622
 623         _ShowOrHidePreview();
 624
 625         _kern_set_real_time_clock_is_gmt(fUseGmtTime);
 626 }
 627
 628
 629 void
 630 TimeZoneView::_ShowOrHidePreview()
 631 {
 632         if (fUseGmtTime) {
 633                 // Hardware clock uses GMT time, changing timezone will adjust the
 634                 // offset and we need to display a preview
 635                 fCurrent->Show();
 636                 fPreview->Show();
 637         } else {
 638                 // Hardware clock uses local time, changing timezone will adjust the
 639                 // clock and there is no offset to manage, thus, no preview.
 640                 fCurrent->Hide();
 641                 fPreview->Hide();
 642         }
 643 }