Ticket #2412: time_pref_net2.patch

src/preferences/time/ntp.cpp

@@ +1 @@
+/*
+ * Copyright 2004-2009, pinc Software. All Rights Reserved.
+ * Distributed under the terms of the MIT license.
+ */
+
+#include "ntp.h"
+
+#include <errno.h>
+#include <netdb.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <OS.h>
+
+
+/* This structure and its data fields are described in RFC 1305
+ * "Network Time Protocol (Version 3)" in appendix A.
+ */
+
+struct fixed32 {
+    int16   integer;
+    uint16  fraction;
+
+    void
+    SetTo(int16 integer, uint16 fraction = 0)
+    {
+        this->integer = htons(integer);
+        this->fraction = htons(fraction);
+    }
+
+    int16 Integer() { return htons(integer); }
+    uint16 Fraction() { return htons(fraction); }
+};
+
+struct ufixed64 {
+    uint32  integer;
+    uint32  fraction;
+
+    void
+    SetTo(uint32 integer, uint32 fraction = 0)
+    {
+        this->integer = htonl(integer);
+        this->fraction = htonl(fraction);
+    }
+
+    uint32 Integer() { return htonl(integer); }
+    uint32 Fraction() { return htonl(fraction); }
+};
+
+struct ntp_data {
+    uint8       mode : 3;
+    uint8       version : 3;
+    uint8       leap_indicator : 2;
+
+    uint8       stratum;
+    int8        poll;
+    int8        precision;  /* in seconds of the nearest power of two */
+
+    fixed32     root_delay;
+    fixed32     root_dispersion;
+    uint32      root_identifier;
+
+    ufixed64    reference_timestamp;
+    ufixed64    originate_timestamp;
+    ufixed64    receive_timestamp;
+    ufixed64    transmit_timestamp;
+
+    /* optional authenticator follows (96 bits) */
+};
+
+#define NTP_PORT        123
+#define NTP_VERSION_3   3
+
+enum ntp_leap_warnings {
+    LEAP_NO_WARNING = 0,
+    LEAP_LAST_MINUTE_61_SECONDS,
+    LEAP_LAST_MINUTE_59_SECONDS,
+    LEAP_CLOCK_NOT_IN_SYNC,
+};
+
+enum ntp_modes {
+    MODE_RESERVED = 0,
+    MODE_SYMMETRIC_ACTIVE,
+    MODE_SYMMETRIC_PASSIVE,
+    MODE_CLIENT,
+    MODE_SERVER,
+    MODE_BROADCAST,
+    MODE_NTP_CONTROL_MESSAGE,
+};
+
+
+const uint32 kUTCtoGMT = 12 * 60 * 60;
+
+
+uint32
+seconds_system_difference(void)
+{
+    const uint32 kYear2000 = 3155713200UL;
+        // that many seconds from year 1900 to 2000.
+
+    struct tm tm;
+    memset(&tm, 0, sizeof(struct tm));
+    tm.tm_mday = 1;
+    tm.tm_year = 100;
+
+    return kYear2000 - mktime(&tm);
+}
+
+
+uint32
+seconds_since_1900()
+{
+    return seconds_system_difference() + real_time_clock();
+}
+
+
+status_t
+ntp_update_time(const char* hostname, const char** errorString,
+    int32* errorCode)
+{
+    hostent *server = gethostbyname(hostname);
+
+    if (server == NULL) {
+    
+        *errorString = "Could not contact server";
+        return B_ENTRY_NOT_FOUND;
+    }
+
+    ntp_data message;
+    memset(&message, 0, sizeof(ntp_data));
+
+    message.leap_indicator = LEAP_CLOCK_NOT_IN_SYNC;
+    message.version = NTP_VERSION_3;
+    message.mode = MODE_CLIENT;
+
+    message.stratum = 1;    // primary reference
+    message.precision = -5; // 2^-5 ~ 32-64 Hz precision
+
+    message.root_delay.SetTo(1);    // 1 sec
+    message.root_dispersion.SetTo(1);
+
+    message.transmit_timestamp.SetTo(seconds_since_1900());
+
+    int connection = socket(AF_INET, SOCK_DGRAM, 0);
+    if (connection < 0) {
+        *errorString = "Could not create socket";
+        *errorCode = errno;
+        return B_ERROR;
+    }
+
+    struct sockaddr_in address;
+    address.sin_family = AF_INET;
+    address.sin_port = htons(NTP_PORT);
+    address.sin_addr.s_addr = *(uint32 *)server->h_addr_list[0];
+
+    if (sendto(connection, (char *)&message, sizeof(ntp_data),
+            0, (struct sockaddr *)&address, sizeof(address)) < 0) {
+        *errorString = "Sending request failed";
+        *errorCode = errno;
+        return B_ERROR;
+    }
+
+    fd_set waitForReceived;
+    FD_ZERO(&waitForReceived);
+    FD_SET(connection, &waitForReceived);
+
+    struct timeval timeout;
+    timeout.tv_sec = 3;
+    timeout.tv_usec = 0;
+    // we'll wait 3 seconds for the answer
+
+    if (select(connection + 1, &waitForReceived, NULL, NULL, &timeout) <= 0) {
+        *errorString = "Waiting for answer failed";
+        *errorCode = errno;
+        return B_ERROR;
+    }
+
+    message.transmit_timestamp.SetTo(0);
+
+    socklen_t addressSize = sizeof(address);
+    if (recvfrom(connection, (char *)&message, sizeof(ntp_data), 0,
+            (sockaddr *)&address, &addressSize) < (ssize_t)sizeof(ntp_data)) {
+        *errorString = "Message receiving failed";
+        *errorCode = errno;
+        close(connection);
+        return B_ERROR;
+    }
+
+    close(connection);
+
+    if (message.transmit_timestamp.Integer() == 0) {
+        *errorString = "Received invalid time";
+        return B_BAD_VALUE;
+    }
+
+    time_t now = message.transmit_timestamp.Integer() - 
+        seconds_system_difference() + kUTCtoGMT;
+    set_real_time_clock(now);
+    return B_OK;
+}

src/preferences/time/Time.h

@@ -31 +31 @@
 
 
 #endif  // _TIME_H
-

src/preferences/time/NetworkTimeView.cpp

@@ +1 @@
+/*
+ * Copyright 2011, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Hamish Morrison <hamish@lavabit.com>
+ *      Axel Dörfler <axeld@pinc-software.de>
+ */
+ 
+#include "NetworkTimeView.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <Alert.h>
+#include <Button.h>
+#include <CheckBox.h>
+#include <File.h>
+#include <FindDirectory.h>
+#include <ListView.h>
+#include <Path.h>
+#include <ScrollView.h>
+#include <TextControl.h>
+
+#include "ntp.h"
+#include "TimeMessages.h"
+
+
+Settings::Settings()
+    :
+    fMessage(kMsgNetworkTimeSettings)
+{
+    ResetToDefaults();
+    Load();
+}
+
+
+Settings::~Settings()
+{
+    Save();
+}
+
+
+void
+Settings::AddServer(const char* server)
+{
+    if (_GetStringByValue("server", server) == B_ERROR)
+        fMessage.AddString("server", server);
+}
+
+
+const char*
+Settings::GetServer(int32 index) const
+{
+    const char* server;
+    fMessage.FindString("server", index, &server);
+    return server;
+}
+
+
+void
+Settings::RemoveServer(const char* server)
+{
+    int32 index = _GetStringByValue("server", server);
+    if (index != B_ERROR) {
+        fMessage.RemoveData("server", index);
+        
+        int32 count;
+        fMessage.GetInfo("server", NULL, &count);
+        if (GetDefaultServer() >= count)
+            SetDefaultServer(count - 1);
+    }
+}
+
+
+void
+Settings::SetDefaultServer(int32 index)
+{
+    if (fMessage.ReplaceInt32("default server", index) != B_OK)
+        fMessage.AddInt32("default server", index);
+}
+
+
+int32
+Settings::GetDefaultServer() const
+{
+    int32 index;
+    fMessage.FindInt32("default server", &index);
+    return index;
+}
+
+
+void
+Settings::SetTryAllServers(bool boolean)
+{
+    fMessage.ReplaceBool("try all servers", boolean);
+}
+
+
+bool
+Settings::GetTryAllServers() const
+{
+    bool boolean;
+    fMessage.FindBool("try all servers", &boolean);
+    return boolean;
+}
+
+
+void
+Settings::SetSynchronizeAtBoot(bool boolean)
+{
+    fMessage.ReplaceBool("synchronize at boot", boolean);
+}
+
+
+bool
+Settings::GetSynchronizeAtBoot() const
+{
+    bool boolean;
+    fMessage.FindBool("synchronize at boot", &boolean);
+    return boolean;
+}
+
+
+void
+Settings::ResetServersToDefaults()
+{
+    fMessage.RemoveName("server");
+
+    fMessage.AddString("server", "pool.ntp.org");
+    fMessage.AddString("server", "de.pool.ntp.org");
+    fMessage.AddString("server", "time.nist.gov");
+
+    if (fMessage.ReplaceInt32("default server", 0) != B_OK)
+        fMessage.AddInt32("default server", 0);
+}
+
+
+void
+Settings::ResetToDefaults()
+{
+    fMessage.MakeEmpty();
+    ResetServersToDefaults();
+
+    fMessage.AddBool("synchronize at boot", true);
+    fMessage.AddBool("try all servers", true);
+}
+
+
+void
+Settings::Revert()
+{
+    fMessage = fOldMessage;
+}
+
+
+bool
+Settings::SettingsChanged()
+{
+    ssize_t oldSize = fOldMessage.FlattenedSize();
+    ssize_t newSize = fMessage.FlattenedSize();
+    
+    if (oldSize != newSize)
+        return true;
+
+    char* oldBytes = new char[oldSize];
+    fOldMessage.Flatten(oldBytes, oldSize);
+    char* newBytes = new char[newSize];
+    fMessage.Flatten(newBytes, newSize);
+    
+    int result = memcmp(oldBytes, newBytes, oldSize);   
+    delete[] oldBytes, newBytes;
+    if (result != 0)
+        return true;
+    else
+        return false;
+}
+
+
+status_t
+Settings::Load()
+{
+    status_t status;
+
+    BPath path;
+    if ((status = _GetPath(path)) != B_OK)
+        return status;
+
+    BFile file(path.Path(), B_READ_ONLY);
+    if ((status = file.InitCheck()) != B_OK)
+        return status;
+
+    BMessage load;
+    if ((status = load.Unflatten(&file)) != B_OK)
+        return status;
+
+    if (load.what != kMsgNetworkTimeSettings)
+        return B_BAD_TYPE;
+
+    fMessage = load;
+    fOldMessage = fMessage;
+    return B_OK;
+}
+
+
+status_t
+Settings::Save()
+{
+    status_t status;
+
+    BPath path;
+    if ((status = _GetPath(path)) != B_OK)
+        return status;
+
+    BFile file(path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
+    if ((status = file.InitCheck()) != B_OK)
+        return status;
+
+    file.SetSize(0);
+
+    return fMessage.Flatten(&file);
+}
+
+
+int32
+Settings::_GetStringByValue(const char* name, const char* value)
+{
+    const char* string;
+    for (int32 index = 0; fMessage.FindString(
+        name, index, &string) == B_OK; index++)
+        if (strcmp(string, value) == 0)
+            return index;
+    return B_ERROR;
+}
+
+
+status_t
+Settings::_GetPath(BPath& path)
+{
+    status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
+    if (status != B_OK)
+        return status;
+    path.Append("pinc.networktime settings");
+    return B_OK;
+}
+
+
+NetworkTimeView::NetworkTimeView(const char* name)
+    :
+    BGroupView(name, B_VERTICAL, B_USE_DEFAULT_SPACING),
+    fSettings(),
+    fUpdateThread(-1)
+{
+    fSettings.Load();
+    _InitView();
+}
+
+
+void
+NetworkTimeView::MessageReceived(BMessage* message)
+{
+    switch (message->what) {
+        case kMsgSetDefaultServer:
+        {
+            int32 sel = fServerListView->CurrentSelection();
+            if (sel < 0)
+                fServerListView->Select(fSettings.GetDefaultServer());
+            else {
+                fSettings.SetDefaultServer(sel);
+                Looper()->PostMessage(new BMessage(kMsgChange));
+            }
+            break;
+        }
+        case kMsgAddServer:
+            fSettings.AddServer(fServerTextControl->Text());
+            _UpdateServerList();
+            Looper()->PostMessage(new BMessage(kMsgChange));
+            break;
+
+        case kMsgRemoveServer:
+            fSettings.RemoveServer(((BStringItem*)
+                fServerListView->ItemAt(
+                    fServerListView->
+                    CurrentSelection()))->Text());
+            _UpdateServerList();
+            Looper()->PostMessage(new BMessage(kMsgChange));
+            break;
+            
+        case kMsgResetServerList:
+            fSettings.ResetServersToDefaults();
+            _UpdateServerList();
+            Looper()->PostMessage(new BMessage(kMsgChange));
+            break;
+        
+        case kMsgTryAllServers:
+            fSettings.SetTryAllServers(
+                fTryAllServersCheckBox->Value());
+            Looper()->PostMessage(new BMessage(kMsgChange));
+            break;
+
+        case kMsgSynchronizeAtBoot:
+            fSettings.SetSynchronizeAtBoot(
+                fSynchronizeAtBootCheckBox->Value());
+            Looper()->PostMessage(new BMessage(kMsgChange));
+            break;
+
+        case kMsgStopSynchronization:
+            if (fUpdateThread >= B_OK)
+                kill_thread(fUpdateThread);
+            _DoneSynchronizing();
+            break;
+
+        case kMsgSynchronize:
+        {
+            if (fUpdateThread >= B_OK)
+                break;
+
+            BMessenger* messenger = new BMessenger(this);
+            update_time(fSettings, messenger, &fUpdateThread);
+            fSynchronizeButton->SetLabel("Stop");
+            fSynchronizeButton->Message()->what = kMsgStopSynchronization;
+            break;
+        }
+
+        case kMsgSynchronizationResult:
+        {
+            _DoneSynchronizing();
+            
+            status_t status;
+            if (message->FindInt32("status", (int32 *)&status) == B_OK) {
+                if (status == B_OK) return;
+
+                const char* errorString;
+                message->FindString("error string", &errorString);  
+                char buffer[256];
+                    
+                int32 errorCode;
+                if (message->FindInt32("error code", &errorCode)
+                    == B_OK)
+                    snprintf(buffer, sizeof(buffer),
+                        "The following error occured "
+                        "while synchronizing:\r\n%s: %s",
+                        errorString, strerror(errorCode));
+                else
+                    snprintf(buffer, sizeof(buffer),
+                        "The following error occured "
+                        "while synchronizing:\r\n%s",
+                        errorString);
+
+                (new BAlert("Time", buffer, "OK"))->Go();
+            }
+            break;
+        }
+        
+        case kMsgRevert:
+            fSettings.Revert();
+            fTryAllServersCheckBox->SetValue(
+                fSettings.GetTryAllServers());
+            fSynchronizeAtBootCheckBox->SetValue(
+                fSettings.GetSynchronizeAtBoot());
+            _UpdateServerList();
+            break;
+    }
+}
+
+
+void
+NetworkTimeView::AttachedToWindow()
+{
+    fServerListView->SetTarget(this);
+    fAddButton->SetTarget(this);
+    fRemoveButton->SetTarget(this);
+    fResetButton->SetTarget(this);
+    fTryAllServersCheckBox->SetTarget(this);
+    fSynchronizeAtBootCheckBox->SetTarget(this);
+    fSynchronizeButton->SetTarget(this);
+}
+
+
+bool
+NetworkTimeView::CheckCanRevert()
+{
+    return fSettings.SettingsChanged();
+}
+
+void
+NetworkTimeView::_InitView()
+{
+    fServerTextControl = new BTextControl(NULL, NULL, NULL);
+
+    fAddButton = new BButton("add", "Add", new BMessage(kMsgAddServer));
+    fRemoveButton = new BButton("remove", "Remove",
+        new BMessage(kMsgRemoveServer));
+    fResetButton = new BButton("reset", "Reset",
+        new BMessage(kMsgResetServerList));
+
+    fServerListView = new BListView("serverList");
+    fServerListView->SetSelectionMessage(new
+        BMessage(kMsgSetDefaultServer));
+    BScrollView* scrollView = new BScrollView("serverScrollView",
+        fServerListView, B_FRAME_EVENTS | B_WILL_DRAW, false, true);
+    _UpdateServerList();
+    
+    fTryAllServersCheckBox = new BCheckBox("tryAllServers",
+        "Try all servers", new BMessage(kMsgTryAllServers));
+    fTryAllServersCheckBox->SetValue(fSettings.GetTryAllServers());
+    
+    fSynchronizeAtBootCheckBox = new BCheckBox("autoUpdate", 
+        "Synchronize at boot", new BMessage(kMsgSynchronizeAtBoot));
+    fSynchronizeAtBootCheckBox->SetValue(fSettings.GetSynchronizeAtBoot());
+    fSynchronizeButton = new BButton("update", "Synchronize now",
+        new BMessage(kMsgSynchronize));
+    fSynchronizeButton->SetExplicitAlignment(
+        BAlignment(B_ALIGN_RIGHT, B_ALIGN_BOTTOM));
+    
+    BLayoutBuilder::Group<>(this)
+        .AddGroup(B_HORIZONTAL)
+            .AddGroup(B_VERTICAL, 0)
+                .Add(fServerTextControl)
+                .Add(scrollView)
+            .End()
+            .AddGroup(B_VERTICAL)
+                .Add(fAddButton)
+                .Add(fRemoveButton)
+                .Add(fResetButton)
+                .AddGlue()
+            .End()
+        .End()
+        .AddGroup(B_HORIZONTAL)
+            .AddGroup(B_VERTICAL)
+                .Add(fTryAllServersCheckBox)
+                .Add(fSynchronizeAtBootCheckBox)
+            .End()
+            .Add(fSynchronizeButton)
+        .End()
+        .SetInsets(5, 5, 5, 5);
+}
+
+
+void
+NetworkTimeView::_UpdateServerList()
+{
+    while (fServerListView->RemoveItem(0L) != NULL);
+
+    const char* server;
+    int32 index = 0;
+
+    while ((server = fSettings.GetServer(index++)) != NULL)
+        fServerListView->AddItem(new BStringItem(server));
+
+    fServerListView->Select(fSettings.GetDefaultServer());
+    fServerListView->ScrollToSelection();
+}
+
+
+void
+NetworkTimeView::_DoneSynchronizing()
+{
+    fUpdateThread = -1;
+    fSynchronizeButton->SetLabel("Synchronize");
+    fSynchronizeButton->Message()->what = kMsgSynchronize;
+}
+
+
+status_t
+update_time(const Settings& settings, const char** errorString,
+    int32* errorCode)
+{
+    int32 defaultServer = settings.GetDefaultServer();
+
+    status_t status = B_ENTRY_NOT_FOUND;
+    const char* server = settings.GetServer(defaultServer);
+    
+    if (server != NULL)
+        status = ntp_update_time(server, errorString, errorCode);
+
+    if (status != B_OK && settings.GetTryAllServers()) {
+        for (int32 index = 0; ; index++) {
+            if (index == defaultServer)
+                index++;
+            server = settings.GetServer(index);
+            if (server == NULL)
+                break;
+
+            status = ntp_update_time(server, errorString, errorCode);
+            if (status == B_OK)
+                break;
+        }
+    }
+    
+    return status;
+}
+
+
+int32
+update_thread(void* params)
+{
+    BList* list = (BList*)params;
+    BMessenger* messenger = (BMessenger*)list->ItemAt(1);
+
+    const char* errorString = NULL;
+    int32 errorCode = 0;
+    status_t status = update_time(*(Settings*)list->ItemAt(0),
+        &errorString, &errorCode);
+
+    BMessage result(kMsgSynchronizationResult);
+    result.AddInt32("status", status);
+    result.AddString("error string", errorString);
+    if (errorCode != 0)
+        result.AddInt32("error code", errorCode);
+    messenger->SendMessage(&result);
+    
+    delete messenger;
+    return B_OK;
+}
+
+
+status_t
+update_time(const Settings& settings, BMessenger* messenger,
+    thread_id* thread)
+{
+    BList* params = new BList(2);
+    params->AddItem((void*)&settings);
+    params->AddItem((void*)messenger);
+    *thread = spawn_thread(update_thread, "ntpUpdate", 64, params);
+    return resume_thread(*thread);
+}

src/preferences/time/TimeZoneListItem.cpp

@@ -1 +1 @@
 /*
- * Copyright 2010, Haiku Inc. All rights reserved.
+ * Copyright 2011, Haiku Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -9 +9 @@
  *      Oliver Tappe <zooey@hirschkaefer.de>
 */
 
-
 #include "TimeZoneListItem.h"
 
 #include <new>

src/preferences/time/BaseView.cpp

@@ -8 +8 @@
  */
 
 #include "BaseView.h"
-#include "TimeMessages.h"
 
-
 #include <DateTime.h>
 #include <OS.h>
 
+#include "TimeMessages.h"
 
-TTimeBaseView::TTimeBaseView(BRect frame, const char* name)
-    : BView(frame, name, B_FOLLOW_NONE, B_PULSE_NEEDED),
-      fMessage(H_TIME_UPDATE)
+
+TTimeBaseView::TTimeBaseView(const char* name)
+    :
+    BGroupView(name, B_VERTICAL, 0),
+    fMessage(H_TIME_UPDATE)
 {
+    SetFlags(Flags() | B_PULSE_NEEDED);
 }
 
 
@@ -108 +110 @@
 
     SendNotices(H_TM_CHANGED, &fMessage);
 }
-

src/preferences/time/ZoneView.cpp

@@ -8 +8 @@
  *      Philippe Saint-Pierre <stpere@gmail.com>
  *      Adrien Destugues <pulkomandy@pulkomandy.ath.cx>
  *      Oliver Tappe <zooey@hirschkaefer.de>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
-
 #include "ZoneView.h"
 
 #include <stdlib.h>
+#include <syscalls.h>
 
 #include <map>
 #include <new>
@@ -36 +37 @@
 #include <StorageDefs.h>
 #include <String.h>
 #include <TimeZone.h>
+#include <ToolTip.h>
 #include <View.h>
 #include <Window.h>
 
-#include <syscalls.h>
-#include <ToolTip.h>
-
 #include <unicode/datefmt.h>
 #include <unicode/utmscale.h>
 #include <ICUWrapper.h>
@@ -49 +48 @@
 #include "TimeMessages.h"
 #include "TimeZoneListItem.h"
 #include "TZDisplay.h"
-#include "TimeWindow.h"
 
 
 #undef B_TRANSLATE_CONTEXT
@@ -77 +75 @@
 
 
 
-TimeZoneView::TimeZoneView(BRect frame)
+TimeZoneView::TimeZoneView(const char* name)
     :
-    BView(frame, "timeZoneView", B_FOLLOW_NONE, B_WILL_DRAW | B_NAVIGABLE_JUMP),
+    BGroupView(name, B_HORIZONTAL, B_USE_DEFAULT_SPACING),
     fToolTip(NULL),
     fCurrentZoneItem(NULL),
     fOldZoneItem(NULL),
@@ -159 +157 @@
         case H_SET_TIME_ZONE:
         {
             _SetSystemTimeZone();
-            ((TTimeWindow*)Window())->SetRevertStatus();
+            Looper()->PostMessage(new BMessage(kMsgChange));
             break;
         }
 
@@ -173 +171 @@
             break;
 
         default:
-            BView::MessageReceived(message);
+            BGroupView::MessageReceived(message);
             break;
     }
 }
@@ -233 +231 @@
 void
 TimeZoneView::_InitView()
 {
-    // left side
-    BRect frameLeft(Bounds());
-    frameLeft.right = frameLeft.Width() / 2.0;
-    frameLeft.InsetBy(10.0f, 10.0f);
-
-    // City Listing
-    fZoneList = new BOutlineListView(frameLeft, "cityList",
-        B_SINGLE_SELECTION_LIST);
+    fZoneList = new BOutlineListView("cityList", B_SINGLE_SELECTION_LIST);
     fZoneList->SetSelectionMessage(new BMessage(H_CITY_CHANGED));
     fZoneList->SetInvocationMessage(new BMessage(H_SET_TIME_ZONE));
-
     _BuildZoneMenu();
-
     BScrollView* scrollList = new BScrollView("scrollList", fZoneList,
-        B_FOLLOW_ALL, 0, false, true);
-    AddChild(scrollList);
+        B_FRAME_EVENTS | B_WILL_DRAW, false, true);
 
-    // right side
-    BRect frameRight(Bounds());
-    frameRight.left = frameRight.Width() / 2.0;
-    frameRight.InsetBy(10.0f, 10.0f);
-    frameRight.top = frameLeft.top;
+    fCurrent = new TTZDisplay("currentTime", B_TRANSLATE("Current time:"));
+    fPreview = new TTZDisplay("previewTime", B_TRANSLATE("Preview time:"));
 
-    // Time Displays
-    fCurrent = new TTZDisplay(frameRight, "currentTime",
-        B_TRANSLATE("Current time:"));
-    AddChild(fCurrent);
-    fCurrent->ResizeToPreferred();
-
-    frameRight.top = fCurrent->Frame().bottom + 10.0;
-    fPreview = new TTZDisplay(frameRight, "previewTime",
-        B_TRANSLATE("Preview time:"));
-    AddChild(fPreview);
-    fPreview->ResizeToPreferred();
-
-    // set button
-    fSetZone = new BButton(frameRight, "setTimeZone",
-        B_TRANSLATE("Set time zone"),
+    fSetZone = new BButton("setTimeZone", B_TRANSLATE("Set time zone"),
         new BMessage(H_SET_TIME_ZONE));
-    AddChild(fSetZone);
     fSetZone->SetEnabled(false);
-    fSetZone->ResizeToPreferred();
-
-    fSetZone->MoveTo(frameRight.right - fSetZone->Bounds().Width(),
-        scrollList->Frame().bottom - fSetZone->Bounds().Height());
+    fSetZone->SetExplicitAlignment(
+        BAlignment(B_ALIGN_RIGHT, B_ALIGN_BOTTOM));
+    
+    BLayoutBuilder::Group<>(this)
+        .Add(scrollList)
+        .AddGroup(B_VERTICAL, 5)
+            .Add(fCurrent)
+            .Add(fPreview)
+            .AddGlue()
+            .Add(fSetZone)
+        .End()
+        .SetInsets(5, 5, 5, 5);
 }
 
 
@@ -336 +314 @@
 
             BString region(zoneID, slashPos);
 
-            if (region == "Etc")
+            if (region == B_TRANSLATE("Etc"))
                 region = kOtherRegion;
             else if (countryName.Length() == 0) {
                 // skip global timezones from other regions, we are just

src/preferences/time/DateTimeEdit.h

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      McCall <mccall@@digitalparadise.co.uk>
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
- *
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 #ifndef _DATE_TIME_EDIT_H
 #define _DATE_TIME_EDIT_H
 
 
-#include "SectionEdit.h"
-
 #include <DateTime.h>
 #include <Locale.h>
 #include <String.h>
 
+#include "SectionEdit.h"
 
+
 class TTimeEdit : public TSectionEdit {
 public:
-                                TTimeEdit(BRect frame, const char* name,
-                                    uint32 sections);
+                                TTimeEdit(const char* name, uint32 sections);
     virtual                     ~TTimeEdit();
 
     virtual void                KeyDown(const char* bytes, int32 numBytes);
 
     virtual void                InitView();
-    virtual void                DrawSection(uint32 index, bool isfocus);
-    virtual void                DrawSeparator(uint32 index);
+    virtual void                DrawSection(uint32 index, BRect bounds,
+                                    bool isfocus);
+    virtual void                DrawSeparator(uint32 index, BRect bounds);
 
-    virtual void                SetSections(BRect area);
     virtual void                SectionFocus(uint32 index);
-    virtual float               SeparatorWidth() const;
+    virtual float               MinSectionWidth();
+    virtual float               SeparatorWidth();
 
+    virtual float               PreferredHeight();
     virtual void                DoUpPress();
     virtual void                DoDownPress();
 
@@ -48 +49 @@
             bool                _IsValidDoubleDigit(int32 value);
             int32               _SectionValue(int32 index) const;
 
-private:
             BDateTime           fTime;
             bigtime_t           fLastKeyDownTime;
             int32               fLastKeyDownInt;
@@ -65 +65 @@
 
 class TDateEdit : public TSectionEdit {
 public:
-                                TDateEdit(BRect frame, const char* name,
-                                    uint32 sections);
+                                TDateEdit(const char* name, uint32 sections);
     virtual                     ~TDateEdit();
     virtual void                KeyDown(const char* bytes, int32 numBytes);
 
     virtual void                InitView();
-    virtual void                DrawSection(uint32 index, bool isfocus);
-    virtual void                DrawSeparator(uint32 index);
+    virtual void                DrawSection(uint32 index, BRect bounds, 
+                                    bool isfocus);
+    virtual void                DrawSeparator(uint32 index, BRect bounds);
 
-    virtual void                SetSections(BRect area);
     virtual void                SectionFocus(uint32 index);
-    virtual float               SeparatorWidth() const;
+    virtual float               MinSectionWidth();
+    virtual float               SeparatorWidth();
 
+    virtual float               PreferredHeight();
     virtual void                DoUpPress();
     virtual void                DoDownPress();
 
     virtual void                BuildDispatch(BMessage* message);
+    
 
             void                SetDate(int32 year, int32 month, int32 day);
 
@@ -90 +92 @@
             void                _CheckRange();
             bool                _IsValidDoubleDigit(int32 value);
             int32               _SectionValue(int32 index) const;
-
-private:
+            
             BDate               fDate;
             bigtime_t           fLastKeyDownTime;
             int32               fLastKeyDownInt;
@@ -107 +108 @@
 
 
 #endif  // _DATE_TIME_EDIT_H
-

src/preferences/time/SectionEdit.cpp

@@ -1 +1 @@
 /*
- * Copyright 2004-2007, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
- *
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
-
 #include "SectionEdit.h"
 
 #include <Bitmap.h>
 #include <ControlLook.h>
+#include <LayoutUtils.h>
 #include <List.h>
 #include <Window.h>
 
 #include "TimeMessages.h"
 
 
-TSection::TSection(BRect frame)
-    :
-    fFrame(frame)
-{
-}
-
-
-BRect
-TSection::Bounds() const
-{
-    BRect frame(fFrame);
-    return frame.OffsetByCopy(B_ORIGIN);
-}
-
-
-void
-TSection::SetFrame(BRect frame)
-{
-    fFrame = frame;
-}
-
-
-BRect
-TSection::Frame() const
-{
-    return fFrame;
-}
-
-
 const uint32 kArrowAreaWidth = 16;
 
 
-TSectionEdit::TSectionEdit(BRect frame, const char* name, uint32 sections)
+TSectionEdit::TSectionEdit(const char* name, uint32 sections)
     :
-    BControl(frame, name, NULL, NULL, B_FOLLOW_NONE, B_NAVIGABLE | B_WILL_DRAW),
-    fSectionList(NULL),
+    BControl(name, NULL, NULL, B_WILL_DRAW | B_NAVIGABLE),
     fFocus(-1),
     fSectionCount(sections),
     fHoldValue(0)
 {
-    InitView();
 }
 
 
 TSectionEdit::~TSectionEdit()
 {
-    int32 count = fSectionList->CountItems();
-    if (count > 0) {
-        for (int32 index = 0; index < count; index++)
-            delete (TSection*)fSectionList->ItemAt(index);
-    }
-    delete fSectionList;
 }
 
 
@@ -88 +51 @@
     DrawBorder(updateRect);
 
     for (uint32 idx = 0; idx < fSectionCount; idx++) {
-        DrawSection(idx, ((uint32)fFocus == idx) && IsFocus());
+        DrawSection(idx, FrameForSection(idx),
+            ((uint32)fFocus == idx) && IsFocus());
         if (idx < fSectionCount - 1)
-            DrawSeparator(idx);
+            DrawSeparator(idx, FrameForSeparator(idx));
     }
 }
 
@@ -104 +68 @@
         DoUpPress();
     else if (fDownRect.Contains(where))
         DoDownPress();
-    else if (fSectionList->CountItems() > 0) {
-        TSection* section;
+    else if (fSectionCount > 0) {
         for (uint32 idx = 0; idx < fSectionCount; idx++) {
-            section = (TSection*)fSectionList->ItemAt(idx);
-            if (section->Frame().Contains(where)) {
+            if (FrameForSection(idx).Contains(where)) {
                 SectionFocus(idx);
                 return;
             }
@@ -117 +79 @@
 }
 
 
+BSize
+TSectionEdit::MaxSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
+        BSize(B_SIZE_UNLIMITED, PreferredHeight()));
+}
+
+
+BSize
+TSectionEdit::MinSize()
+{
+    BSize minSize;
+    minSize.height = PreferredHeight();
+    minSize.width = (SeparatorWidth() + MinSectionWidth())
+        * fSectionCount;
+    return BLayoutUtils::ComposeSize(ExplicitMinSize(),
+        minSize);
+}
+
+
+BSize
+TSectionEdit::PreferredSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitPreferredSize(),
+        MinSize());
+}
+
+
+BRect
+TSectionEdit::FrameForSection(uint32 index)
+{
+    BRect area = SectionArea();
+    float sepWidth = SeparatorWidth();
+    
+    float width = (area.Width() -
+        sepWidth * (fSectionCount - 1))
+        / fSectionCount;
+    area.left += index * (width + sepWidth);
+    area.right = area.left + width;
+
+    return area;
+}
+
+
+BRect
+TSectionEdit::FrameForSeparator(uint32 index)
+{
+    BRect area = SectionArea();
+    float sepWidth = SeparatorWidth();
+
+    float width = (area.Width() -
+        sepWidth * (fSectionCount - 1))
+        / fSectionCount;
+    area.left += (index + 1) * width + index * sepWidth;
+    area.right = area.left + sepWidth;
+
+    return area;
+}
+
+
 void
 TSectionEdit::MakeFocus(bool focused)
 {
@@ -181 +203 @@
 uint32
 TSectionEdit::CountSections() const
 {
-    return fSectionList->CountItems();
+    return fSectionCount;
 }
 
 
@@ -192 +214 @@
 }
 
 
-void
-TSectionEdit::InitView()
+BRect
+TSectionEdit::SectionArea() const
 {
-    // setup sections
-    fSectionList = new BList(fSectionCount);
-    fSectionArea = Bounds().InsetByCopy(2, 2);
-    fSectionArea.right -= kArrowAreaWidth;
+    BRect sectionArea = Bounds().InsetByCopy(2, 2);
+    sectionArea.right -= kArrowAreaWidth;
+    return sectionArea;
 }
 
 
@@ -219 +240 @@
         bounds.bottom / 2.0);
     fDownRect = fUpRect.OffsetByCopy(0, fUpRect.Height() + 2);
 
-    BPoint middle(floorf(fUpRect.left + fUpRect.Width() / 2), fUpRect.top + 1);
+    BPoint middle(floorf(fUpRect.left + fUpRect.Width() / 2),
+        fUpRect.top + 1);
     BPoint left(fUpRect.left + 3, fUpRect.bottom - 1);
     BPoint right(left.x + 2 * (middle.x - left.x), fUpRect.bottom - 1);
 
     SetPenSize(2);
+    SetLowColor(ViewColor());
 
     if (updateRect.Intersects(fUpRect)) {
         FillRect(fUpRect, B_SOLID_LOW);
@@ -245 +268 @@
 
     SetPenSize(1);
 }
-
-
-float
-TSectionEdit::SeparatorWidth() const
-{
-    return 0.0f;
-}

src/preferences/time/TimeSettings.cpp

@@ -19 +19 @@
 
 
 TimeSettings::TimeSettings()
-    : fSettingsFile("Time_preflet_window")
+    :
+    fSettingsFile("Time_preflet_window")
 {
 }
 
@@ -63 +64 @@
     if (file.InitCheck() == B_OK)
         file.Write(&leftTop, sizeof(BPoint));
 }
-

src/preferences/time/AnalogClock.h

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 #ifndef _ANALOG_CLOCK_H
 #define _ANALOG_CLOCK_H
@@ -13 +14 @@
 #include <View.h>
 
 
-class BBitmap;
-class OffscreenClock;
-
-
 class TAnalogClock : public BView {
 public:
-                                TAnalogClock(BRect frame, const char* name,
-                                    bool drawSecondHand = true, bool interactive = true);
-    virtual                     ~TAnalogClock();
+                            TAnalogClock(const char* name,
+                                bool drawSecondHand = true,
+                                bool interactive = true);
+    virtual                 ~TAnalogClock();
 
-    virtual void                AttachedToWindow();
-    virtual void                Draw(BRect updateRect);
-    virtual void                MessageReceived(BMessage* message);
-    virtual void                MouseDown(BPoint point);
-    virtual void                MouseUp(BPoint point);
-    virtual void                MouseMoved(BPoint point, uint32 transit,
-                                    const BMessage* message);
+    virtual void            Draw(BRect updateRect);
+    virtual void            MessageReceived(BMessage* message);
+    virtual void            MouseDown(BPoint point);
+    virtual void            MouseUp(BPoint point);
+    virtual void            MouseMoved(BPoint point, uint32 transit,
+                                const BMessage* message);
+    virtual void            FrameResized(float, float);
+    
+    virtual BSize           MaxSize();
+    virtual BSize           MinSize();
+    virtual BSize           PreferredSize();
 
-            void                SetTime(int32 hour, int32 minute, int32 second);
+            void            SetTime(int32 hour, int32 minute, int32 second);
+            bool            IsChangingTime();
+            void            ChangeTimeFinished();
 
-            bool                IsChangingTime()
-                                    {   return fTimeChangeIsOngoing;    }
-            void                ChangeTimeFinished();
+            void            GetTime(int32* hour, int32* minute, int32* second);
+            void            DrawClock();
+
+            bool            InHourHand(BPoint point);
+            bool            InMinuteHand(BPoint point);
+
+            void            SetHourHand(BPoint point);
+            void            SetMinuteHand(BPoint point);
+
+            void            SetHourDragging(bool dragging);
+            void            SetMinuteDragging(bool dragging);
 private:
-            void                _InitView(BRect frame);
+            float           _GetPhi(BPoint point);
+            bool            _InHand(BPoint point, int32 ticks, float radius);
+            void            _DrawHands(float x, float y, float radius,
+                                rgb_color hourHourColor,
+                                rgb_color hourMinuteColor,
+                                rgb_color secondsColor, rgb_color knobColor);
 
-            BBitmap*            fBitmap;
-            OffscreenClock*     fClock;
+            int32           fHours;
+            int32           fMinutes;
+            int32           fSeconds;
+            bool            fDirty;
+            
+            float           fCenterX;
+            float           fCenterY;
+            float           fRadius;
 
-            bool                fDrawSecondHand;
-            bool                fInteractive;
-            bool                fDraggingHourHand;
-            bool                fDraggingMinuteHand;
+            bool            fHourDragging;
+            bool            fMinuteDragging;
+            bool            fDrawSecondHand;
+            bool            fInteractive;
 
-            bool                fTimeChangeIsOngoing;
+            bool            fTimeChangeIsOngoing;   
 };
 
 

src/preferences/time/TimeWindow.cpp

@@ -1 +1 @@
 /*
- * Copyright 2004-2007, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Andrew McCall <mccall@@digitalparadise.co.uk>
  *      Julun <host.haiku@gmx.de>
- *
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
 #include "TimeWindow.h"
-#include "BaseView.h"
-#include "DateTimeView.h"
-#include "TimeMessages.h"
-#include "TimeSettings.h"
-#include "ZoneView.h"
 
-
 #include <Application.h>
+#include <Button.h>
 #include <Catalog.h>
+#include <LayoutBuilder.h>
 #include <Message.h>
 #include <Screen.h>
 #include <TabView.h>
-#include <Button.h>
 
+#include "BaseView.h"
+#include "DateTimeView.h"
+#include "NetworkTimeView.h"
+#include "TimeMessages.h"
+#include "TimeSettings.h"
+#include "ZoneView.h"
+
+
 #undef B_TRANSLATE_CONTEXT
 #define B_TRANSLATE_CONTEXT "Time"
 
-TTimeWindow::TTimeWindow(BRect rect)
-    : BWindow(rect, B_TRANSLATE("Time"), B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE)
+
+TTimeWindow::TTimeWindow()
+    :
+    BWindow(BRect(0, 0, 0, 0), B_TRANSLATE("Time"), B_TITLED_WINDOW,
+        B_NOT_RESIZABLE | B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS)
 {
     _InitWindow();
     _AlignWindow();
@@ -41 +47 @@
 }
 
 
-void
-TTimeWindow::SetRevertStatus()
+bool
+TTimeWindow::QuitRequested()
 {
-    fRevertButton->SetEnabled(fDateTimeView->CheckCanRevert()
-        || fTimeZoneView->CheckCanRevert());
+    TimeSettings().SetLeftTop(Frame().LeftTop());
+
+    fBaseView->StopWatchingAll(fTimeZoneView);
+    fBaseView->StopWatchingAll(fDateTimeView);
+
+    be_app->PostMessage(B_QUIT_REQUESTED);
+
+    return BWindow::QuitRequested();
 }
 
 
@@ -57 +69 @@
             fBaseView->ChangeTime(message);
             // To make sure no old time message is in the queue
             _SendTimeChangeFinished();
-            SetRevertStatus();
+            _SetRevertStatus();
             break;
 
         case B_ABOUT_REQUESTED:
@@ -67 +79 @@
         case kMsgRevert:
             fDateTimeView->MessageReceived(message);
             fTimeZoneView->MessageReceived(message);
+            fNetworkTimeView->MessageReceived(message);
             fRevertButton->SetEnabled(false);
             break;
 
         case kRTCUpdate:
             fDateTimeView->MessageReceived(message);
             fTimeZoneView->MessageReceived(message);
-            SetRevertStatus();
+            _SetRevertStatus();
             break;
 
+        case kMsgChange:
+            _SetRevertStatus();
+            break;
+
         default:
             BWindow::MessageReceived(message);
             break;
@@ -83 +100 @@
 }
 
 
-bool
-TTimeWindow::QuitRequested()
-{
-    TimeSettings().SetLeftTop(Frame().LeftTop());
-
-    fBaseView->StopWatchingAll(fTimeZoneView);
-    fBaseView->StopWatchingAll(fDateTimeView);
-
-    be_app->PostMessage(B_QUIT_REQUESTED);
-
-    return BWindow::QuitRequested();
-}
-
-
 void
 TTimeWindow::_InitWindow()
 {
     SetPulseRate(500000);
 
-    fDateTimeView = new DateTimeView(Bounds());
+    fDateTimeView = new DateTimeView(B_TRANSLATE("Date and time"));
+    fTimeZoneView = new TimeZoneView(B_TRANSLATE("Time zone"));
+    fNetworkTimeView = new NetworkTimeView(B_TRANSLATE("Network time"));
 
-    BRect bounds = fDateTimeView->Bounds();
-    fTimeZoneView = new TimeZoneView(bounds);
-
-    fBaseView = new TTimeBaseView(bounds, "baseView");
-    AddChild(fBaseView);
-
+    fBaseView = new TTimeBaseView("baseView");
     fBaseView->StartWatchingAll(fDateTimeView);
     fBaseView->StartWatchingAll(fTimeZoneView);
 
-    bounds.OffsetBy(10.0, 10.0);
-    BTabView* tabView = new BTabView(bounds.InsetByCopy(-5.0, -5.0),
-        "tabView" , B_WIDTH_AS_USUAL, B_FOLLOW_NONE);
-
-    BTab* tab = new BTab();
-    tabView->AddTab(fDateTimeView, tab);
-    tab->SetLabel(B_TRANSLATE("Date & Time"));
-
-    tab = new BTab();
-    tabView->AddTab(fTimeZoneView, tab);
-    tab->SetLabel(B_TRANSLATE("Time zone"));
-
+    BTabView* tabView = new BTabView("tabView");
+    tabView->AddTab(fDateTimeView);
+    tabView->AddTab(fTimeZoneView);
+    tabView->AddTab(fNetworkTimeView);
+    
     fBaseView->AddChild(tabView);
-    tabView->ResizeBy(0.0, tabView->TabHeight());
 
-    BRect rect = Bounds();
-
-    rect.left = 10;
-    rect.top = rect.bottom - 10;
-
-    fRevertButton = new BButton(rect, "revert", B_TRANSLATE("Revert"),
-        new BMessage(kMsgRevert), B_FOLLOW_LEFT | B_FOLLOW_BOTTOM, B_WILL_DRAW);
-
-    fRevertButton->ResizeToPreferred();
+    fRevertButton = new BButton("revert", B_TRANSLATE("Revert"),
+        new BMessage(kMsgRevert));
     fRevertButton->SetEnabled(false);
-    float buttonHeight = fRevertButton->Bounds().Height();
-    fRevertButton->MoveBy(0, -buttonHeight);
-    fBaseView->AddChild(fRevertButton);
     fRevertButton->SetTarget(this);
-
-    fBaseView->ResizeTo(tabView->Bounds().Width() + 10.0,
-        tabView->Bounds().Height() + buttonHeight + 30.0);
-
-    ResizeTo(fBaseView->Bounds().Width(), fBaseView->Bounds().Height());
+    fRevertButton->SetExplicitAlignment(
+        BAlignment(B_ALIGN_LEFT, B_ALIGN_MIDDLE));
+    
+    BLayoutBuilder::Group<>(this, B_VERTICAL, 5)
+        .Add(fBaseView)
+        .Add(fRevertButton)
+        .SetInsets(5, 5, 5, 5);
 }
 
 
@@ -175 +159 @@
     BMessage msg(kChangeTimeFinished);
     messenger.SendMessage(&msg);
 }
+
+
+void
+TTimeWindow::_SetRevertStatus()
+{
+    fRevertButton->SetEnabled(fDateTimeView->CheckCanRevert()
+        || fTimeZoneView->CheckCanRevert()
+        || fNetworkTimeView->CheckCanRevert());
+}

src/preferences/time/Jamfile

@@ -12 +12 @@
     DateTimeEdit.cpp
     SectionEdit.cpp
     DateTimeView.cpp
+    NetworkTimeView.cpp
+    ntp.cpp
     Time.cpp
     TimeSettings.cpp
     TimeWindow.cpp
@@ -28 +30 @@
 
 Preference Time
     : $(sources)
-    : be libshared.a $(TARGET_LIBSTDC++) $(HAIKU_LOCALE_LIBS)
+    : be libshared.a $(TARGET_LIBSTDC++) $(HAIKU_LOCALE_LIBS) $(HAIKU_NETWORK_LIBS)
     : Time.rdef
     ;
 

src/preferences/time/DateTimeView.cpp

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -7 +7 @@
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
  *      Philippe Saint-Pierre <stpere@gmail.com>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
 #include "DateTimeView.h"
-#include "AnalogClock.h"
-#include "DateTimeEdit.h"
-#include "TimeMessages.h"
-#include "TimeWindow.h"
 
+#include <time.h>
+#include <syscalls.h>
+
+#include <Box.h>
 #include <CalendarView.h>
 #include <Catalog.h>
 #include <CheckBox.h>
@@ -25 +26 @@
 #include <Message.h>
 #include <Path.h>
 #include <RadioButton.h>
-#include <String.h>
 #include <StringView.h>
 #include <Window.h>
 
-#include <time.h>
+#include "AnalogClock.h"
+#include "DateTimeEdit.h"
+#include "TimeMessages.h"
+#include "TimeWindow.h"
 
-#include <syscalls.h>
 
 #undef B_TRANSLATE_CONTEXT
 #define B_TRANSLATE_CONTEXT "Time"
@@ -42 +44 @@
 using BPrivate::B_LOCAL_TIME;
 
 
-DateTimeView::DateTimeView(BRect frame)
-    : BView(frame, "dateTimeView", B_FOLLOW_NONE, B_WILL_DRAW
-        | B_NAVIGABLE_JUMP),
+DateTimeView::DateTimeView(const char* name)
+    : 
+    BGroupView(name, B_HORIZONTAL, 5),
     fGmtTime(NULL),
     fUseGmtTime(false),
     fInitialized(false),
@@ -208 +210 @@
 void
 DateTimeView::_InitView()
 {
-    font_height fontHeight;
-    be_plain_font->GetHeight(&fontHeight);
-    float textHeight = fontHeight.descent + fontHeight.ascent
-        + fontHeight.leading + 6.0; // 6px border
-
-    // left side
-    BRect bounds = Bounds();
-    bounds.InsetBy(10.0, 10.0);
-    bounds.top += textHeight + 10.0;
-
-    fCalendarView = new BCalendarView(bounds, "calendar");
+    fCalendarView = new BCalendarView("calendar");
     fCalendarView->SetWeekNumberHeaderVisible(false);
-    fCalendarView->ResizeToPreferred();
     fCalendarView->SetSelectionMessage(new BMessage(kDayChanged));
     fCalendarView->SetInvocationMessage(new BMessage(kDayChanged));
 
-    bounds.top -= textHeight + 10.0;
-    bounds.bottom = bounds.top + textHeight;
-    bounds.right = fCalendarView->Frame().right;
-
-    fDateEdit = new TDateEdit(bounds, "dateEdit", 3);
-    AddChild(fDateEdit);
-    AddChild(fCalendarView);
-
-    // right side, 2px extra for separator
-    bounds.OffsetBy(bounds.Width() + 22.0, 0.0);
-    fTimeEdit = new TTimeEdit(bounds, "timeEdit", 4);
-    AddChild(fTimeEdit);
-
-    bounds = fCalendarView->Frame();
-    bounds.OffsetBy(bounds.Width() + 22.0, 0.0);
-
-    fClock = new TAnalogClock(bounds, "analogClock");
-    AddChild(fClock);
+    fDateEdit = new TDateEdit("dateEdit", 3);
+    fTimeEdit = new TTimeEdit("timeEdit", 4);
+    fClock = new TAnalogClock("analogClock");
+    
     BTime time(BTime::CurrentTime(B_LOCAL_TIME));
     fClock->SetTime(time.Hour(), time.Minute(), time.Second());
 
-    // clock radio buttons
-    bounds.top = fClock->Frame().bottom + 10.0;
-    BStringView* text = new BStringView(bounds, "clockSetTo",
+    BStringView* text = new BStringView("clockSetTo",
         B_TRANSLATE("Clock set to:"));
-    AddChild(text);
-    text->ResizeToPreferred();
-
-    bounds.left += 10.0f;
-    bounds.top = text->Frame().bottom;
-    fLocalTime = new BRadioButton(bounds, "localTime",
+    fLocalTime = new BRadioButton("localTime",
         B_TRANSLATE("Local time"), new BMessage(kRTCUpdate));
-    AddChild(fLocalTime);
-    fLocalTime->ResizeToPreferred();
+    fGmtTime = new BRadioButton("greenwichMeanTime",
+        B_TRANSLATE("GMT"), new BMessage(kRTCUpdate));
 
-    bounds.left = fLocalTime->Frame().right + 10.0;
-    fGmtTime = new BRadioButton(bounds, "greenwichMeanTime",
-        B_TRANSLATE("GMT"), new BMessage(kRTCUpdate));
-    AddChild(fGmtTime);
-    fGmtTime->ResizeToPreferred();
-
     if (fUseGmtTime)
         fGmtTime->SetValue(B_CONTROL_ON);
     else
         fLocalTime->SetValue(B_CONTROL_ON);
-
     fOldUseGmtTime = fUseGmtTime;
 
-    ResizeTo(fClock->Frame().right + 10.0, fGmtTime->Frame().bottom + 10.0);
+    BBox* divider = new BBox(BRect(0, 0, 1, 1),
+        B_EMPTY_STRING, B_FOLLOW_ALL_SIDES,
+        B_WILL_DRAW | B_FRAME_EVENTS, B_FANCY_BORDER);
+    divider->SetExplicitMaxSize(BSize(1, B_SIZE_UNLIMITED));
+
+    BLayoutBuilder::Group<>(this)
+        .AddGroup(B_VERTICAL, 5)
+            .Add(fDateEdit)
+            .Add(fCalendarView)
+        .End()
+        .Add(divider)
+        .AddGroup(B_VERTICAL, 5)
+            .Add(fTimeEdit)
+            .Add(fClock)
+            .Add(text)
+            .AddGroup(B_HORIZONTAL, 5)
+                .Add(fLocalTime)
+                .Add(fGmtTime)
+            .End()
+        .End()
+        .SetInsets(5, 5, 5, 5);
 }
 
 

src/preferences/time/TZDisplay.h

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Andrew McCall <mccall@@digitalparadise.co.uk>
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
- *
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 #ifndef _TZ_DISPLAY_H
 #define _TZ_DISPLAY_H
 
 
+#include <String.h>
 #include <View.h>
-#include <String.h>
 
 
 class TTZDisplay : public BView {
 public:
-                                TTZDisplay(BRect frame, const char* name,
+                                TTZDisplay(const char* name,
                                     const char* label);
     virtual                     ~TTZDisplay();
 
     virtual void                AttachedToWindow();
     virtual void                ResizeToPreferred();
     virtual void                Draw(BRect updateRect);
+    
+    virtual BSize               MaxSize();
+    virtual BSize               MinSize();
+    virtual BSize               PreferredSize();
 
             const char*         Label() const;
             void                SetLabel(const char* label);
@@ -36 +40 @@
             void                SetTime(const char* time);
 
 private:
+            BSize               _CalcPrefSize();
+
             BString             fLabel;
             BString             fText;
             BString             fTime;
@@ -43 +49 @@
 
 
 #endif  // _TZ_DISPLAY_H
-

src/preferences/time/Time.cpp

@@ -1 +1 @@
 /*
- * Copyright 2002-2007, Haiku. All rights reserved.
+ * Copyright 2002-2011, Haiku. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Andrew McCall <mccall@digitalparadise.co.uk>
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
 #include "Time.h"
-#include "TimeWindow.h"
 
+#include <stdio.h>
+#include <unistd.h>
 
 #include <Alert.h>
 #include <Catalog.h>
 
-#include <unistd.h>
+#include "NetworkTimeView.h"
+#include "TimeWindow.h"
 
+
 #undef B_TRANSLATE_CONTEXT
 #define B_TRANSLATE_CONTEXT "Time"
 
+
 const char* kAppSignature = "application/x-vnd.Haiku-Time";
 
 
 TimeApplication::TimeApplication()
-    : BApplication(kAppSignature),
-      fWindow(NULL)
+    : 
+    BApplication(kAppSignature),
+    fWindow(NULL)
 {
-    fWindow = new TTimeWindow(BRect(100, 100, 570, 327));
+    fWindow = new TTimeWindow();
 }
 
 
@@ -47 +53 @@
 TimeApplication::AboutRequested()
 {
     BAlert* alert = new BAlert(B_TRANSLATE("about"),
-        B_TRANSLATE("Time & Date, writen by:\n\n\tAndrew Edward McCall\n\tMike Berg\n\t"
-                    "Julun\n\tPhilippe Saint-Pierre\n\nCopyright 2004-2008, Haiku."),
+        B_TRANSLATE(
+        "Time & Date, writen by:\n\n\tAndrew Edward McCall\n\tMike Berg\n\t"
+        "Julun\n\tPhilippe Saint-Pierre\n\nCopyright 2004-2008, Haiku."),
         B_TRANSLATE("OK"));
     alert->Go();
 }
 
 
-//  #pragma mark -
-
-
 int
 main(int argc, char** argv)
 {
-    TimeApplication app;
-    setuid(0);
-    app.Run();
+    if (argc > 1) {
+        if (strcmp(argv[1], "--update") != 0)
+            return 0;
+        
+        Settings settings;
+        if (!settings.GetSynchronizeAtBoot())
+            return 0;
 
+        const char* errorString = NULL;
+        int32 errorCode = 0;
+        if (update_time(settings, &errorString, &errorCode) == B_OK)
+            printf("Synchronization successful\r\n");
+        else if (errorCode != 0)
+            printf("The following error occured "
+                "while synchronizing:\r\n%s: %s\r\n",
+                errorString, strerror(errorCode));
+        else
+            printf("The following error occured "
+                "while synchronizing:\r\n%s\r\n",
+                errorString);
+    }
+    else {
+        TimeApplication app;
+        setuid(0);
+        app.Run();
+    }
+
     return 0;
 }
-

src/preferences/time/DateTimeEdit.cpp

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -8 +8 @@
  *      Julun <host.haiku@gmx.de>
  *      Clemens <mail@Clemens-Zeidler.de>
  *      Adrien Destugues <pulkomandy@pulkomandy.cx>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
-
 #include "DateTimeEdit.h"
 
 #include <stdlib.h>
@@ -24 +24 @@
 using BPrivate::B_LOCAL_TIME;
 
 
-TTimeEdit::TTimeEdit(BRect frame, const char* name, uint32 sections)
+TTimeEdit::TTimeEdit(const char* name, uint32 sections)
     :
-    TSectionEdit(frame, name, sections),
+    TSectionEdit(name, sections),
     fLastKeyDownTime(0),
     fFields(NULL),
     fFieldCount(0),
@@ -57 +57 @@
     int32 section = FocusIndex();
     if (section < 0 || section > 2)
         return;
-
     bigtime_t currentTime = system_time();
     if (currentTime - fLastKeyDownTime < 1000000) {
         int32 doubleDigit = number + fLastKeyDownInt * 10;
@@ -84 +83 @@
 {
     // make sure we call the base class method, as it
     // will create the arrow bitmaps and the section list
-    TSectionEdit::InitView();
-
     fTime = BDateTime::CurrentDateTime(B_LOCAL_TIME);
     _UpdateFields();
-
-    SetSections(fSectionArea);
 }
 
 
 void
-TTimeEdit::DrawSection(uint32 index, bool hasFocus)
+TTimeEdit::DrawSection(uint32 index, BRect bounds, bool hasFocus)
 {
-    TSection* section = static_cast<TSection*>(fSectionList->ItemAt(index));
-    if (!section)
-        return;
-
     if (fFieldPositions == NULL || index * 2 + 1 >= (uint32)fFieldPosCount)
         return;
-
-    BRect bounds = section->Frame();
-
     SetLowColor(ViewColor());
     if (hasFocus)
         SetLowColor(tint_color(ViewColor(), B_DARKEN_1_TINT));
@@ -113 +101 @@
     fText.CopyCharsInto(field, fFieldPositions[index * 2],
         fFieldPositions[index * 2 + 1] - fFieldPositions[index * 2]);
 
-    // calc and center text in section rect
-    float width = be_plain_font->StringWidth(field);
-
-    BPoint offset(-((bounds.Width()- width) / 2.0) - 1.0,
-        bounds.Height() / 2.0 - 6.0);
-
+    BPoint point(bounds.LeftBottom());
+    point.y -= bounds.Height() / 2.0 - 6.0;
+    point.x += (bounds.Width() - StringWidth(field)) / 2;
     SetHighColor(0, 0, 0, 255);
     FillRect(bounds, B_SOLID_LOW);
-    DrawString(field, bounds.LeftBottom() - offset);
+    DrawString(field, point);
 }
 
 
 void
-TTimeEdit::DrawSeparator(uint32 index)
+TTimeEdit::DrawSeparator(uint32 index, BRect bounds)
 {
-    TSection* section = static_cast<TSection*>(fSectionList->ItemAt(index));
-    if (!section)
-        return;
-
     if (fFieldPositions == NULL || index * 2 + 2 >= (uint32)fFieldPosCount)
         return;
 
@@ -139 +120 @@
     fText.CopyCharsInto(field, fFieldPositions[index * 2 + 1],
         fFieldPositions[index * 2 + 2] - fFieldPositions[index * 2 + 1]);
 
-    float sepWidth = SeparatorWidth();
-    BRect bounds = section->Frame();
-    float width = be_plain_font->StringWidth(field);
-    BPoint offset(-((sepWidth - width) / 2.0) - 1.0,
-        bounds.Height() / 2.0 - 6.0);
-    DrawString(field, bounds.RightBottom() - offset);
+    BPoint point(bounds.LeftBottom());
+    point.y -= bounds.Height() / 2.0 - 6.0;
+    point.x += (bounds.Width() - StringWidth(field)) / 2;
+    SetHighColor(0, 0, 0, 255);
+    DrawString(field, point);
 }
 
 
-void
-TTimeEdit::SetSections(BRect area)
+float
+TTimeEdit::SeparatorWidth()
 {
-    // by default divide up the sections evenly
-    BRect bounds(area);
-
-    float sepWidth = SeparatorWidth();
-
-    float sep_2 = ceil(sepWidth / fSectionCount + 1);
-    float width = bounds.Width() / fSectionCount - sep_2;
-    bounds.right = bounds.left + (width - sepWidth / fSectionCount);
-
-    for (uint32 idx = 0; idx < fSectionCount; idx++) {
-        fSectionList->AddItem(new TSection(bounds));
-
-        bounds.left = bounds.right + sepWidth;
-        if (idx == fSectionCount - 2)
-            bounds.right = area.right - 1;
-        else
-            bounds.right = bounds.left + (width - sep_2);
-    }
+    return 10.0f;
 }
 
 
 float
-TTimeEdit::SeparatorWidth() const
+TTimeEdit::MinSectionWidth()
 {
-    return 10.0f;
+    return be_plain_font->StringWidth("00");
 }
 
 
@@ -236 +199 @@
 
     // send message to change time
     DispatchMessage();
+    
 }
 
 
@@ -247 +211 @@
 
     message->AddBool("time", true);
 
-    for (int32 index = 0; index < fSectionList->CountItems() - 1; ++index) {
+    for (int32 index = 0; index < (int)fSectionCount; ++index) {
         uint32 data = _SectionValue(index);
 
         if (fFocus == index)
@@ -277 +241 @@
 TTimeEdit::_UpdateFields()
 {
     time_t time = fTime.Time_t();
-
+    
     if (fFieldPositions != NULL) {
         free(fFieldPositions);
         fFieldPositions = NULL;
     }
-    BLocale::Default()->FormatTime(&fText, fFieldPositions, fFieldPosCount,
-        time, B_MEDIUM_TIME_FORMAT);
+    BLocale::Default()->FormatTime(&fText, fFieldPositions,
+        fFieldPosCount, time, B_MEDIUM_TIME_FORMAT);
 
     if (fFields != NULL) {
         free(fFields);
@@ -415 +379 @@
 }
 
 
+float
+TTimeEdit::PreferredHeight()
+{
+    font_height fontHeight;
+    GetFontHeight(&fontHeight);
+    return ceilf((fontHeight.ascent + fontHeight.descent) * 1.4);
+}
+
+
 //  #pragma mark -
 
 
-TDateEdit::TDateEdit(BRect frame, const char* name, uint32 sections)
+TDateEdit::TDateEdit(const char* name, uint32 sections)
     :
-    TSectionEdit(frame, name, sections),
+    TSectionEdit(name, sections),
     fFields(NULL),
     fFieldCount(0),
     fFieldPositions(NULL),
@@ -486 +459 @@
 {
     // make sure we call the base class method, as it
     // will create the arrow bitmaps and the section list
-    TSectionEdit::InitView();
-
     fDate = BDate::CurrentDate(B_LOCAL_TIME);
     _UpdateFields();
-
-    SetSections(fSectionArea);
 }
 
 
 void
-TDateEdit::DrawSection(uint32 index, bool hasFocus)
+TDateEdit::DrawSection(uint32 index, BRect bounds, bool hasFocus)
 {
-    TSection* section = static_cast<TSection*>(fSectionList->ItemAt(index));
-    if (!section)
-        return;
-
     if (fFieldPositions == NULL || index * 2 + 1 >= (uint32)fFieldPosCount)
         return;
 
@@ -513 +478 @@
     fText.CopyCharsInto(field, fFieldPositions[index * 2],
         fFieldPositions[index * 2 + 1] - fFieldPositions[index * 2]);
 
-    // calc and center text in section rect
-    BRect bounds = section->Frame();
-    float width = StringWidth(field);
-    BPoint offset(-(bounds.Width() - width) / 2.0 - 1.0,
-        (bounds.Height() / 2.0 - 6.0));
-
+    BPoint point(bounds.LeftBottom());
+    point.y -= bounds.Height() / 2.0 - 6.0;
+    point.x += (bounds.Width() - StringWidth(field)) / 2;
     SetHighColor(0, 0, 0, 255);
     FillRect(bounds, B_SOLID_LOW);
-    DrawString(field, bounds.LeftBottom() - offset);
+    DrawString(field, point);
 }
 
 
 void
-TDateEdit::DrawSeparator(uint32 index)
+TDateEdit::DrawSeparator(uint32 index, BRect bounds)
 {
     if (index >= 2)
         return;
 
-    TSection* section = static_cast<TSection*>(fSectionList->ItemAt(index));
-    if (!section)
-        return;
-
     if (fFieldPositions == NULL || index * 2 + 2 >= (uint32)fFieldPosCount)
         return;
 
@@ -542 +500 @@
     fText.CopyCharsInto(field, fFieldPositions[index * 2 + 1],
         fFieldPositions[index * 2 + 2] - fFieldPositions[index * 2 + 1]);
 
-    BRect bounds = section->Frame();
-    float width = be_plain_font->StringWidth(field);
-    float sepWidth = SeparatorWidth();
-    BPoint offset(-((sepWidth - width) / 2.0) - 1.0,
-        bounds.Height() / 2.0 - 6.0);
-
+    BPoint point(bounds.LeftBottom());
+    point.y -= bounds.Height() / 2.0 - 6.0;
+    point.x += (bounds.Width() - StringWidth(field)) / 2;
     SetHighColor(0, 0, 0, 255);
-    DrawString(field, bounds.RightBottom() - offset);
+    DrawString(field, point);
 }
 
 
 void
-TDateEdit::SetSections(BRect area)
+TDateEdit::SectionFocus(uint32 index)
 {
-    // TODO : we have to be more clever here, as the fields can move and have
-    // different sizes depending on the locale
-
-    // create sections
-    for (uint32 idx = 0; idx < fSectionCount; idx++)
-        fSectionList->AddItem(new TSection(area));
-
-    BRect bounds(area);
-    float sepWidth = SeparatorWidth();
-
-    TSection* section = static_cast<TSection*>(fSectionList->ItemAt(0));
-    float width = be_plain_font->StringWidth("0000") + 10;
-    bounds.left = area.left;
-    bounds.right = bounds.left + width;
-    section->SetFrame(bounds);
-
-    section = static_cast<TSection*>(fSectionList->ItemAt(1));
-    width = be_plain_font->StringWidth("0000") + 10;
-    bounds.left = bounds.right + sepWidth;
-    bounds.right = bounds.left + width;
-    section->SetFrame(bounds);
-
-    section = static_cast<TSection*>(fSectionList->ItemAt(2));
-    width = be_plain_font->StringWidth("0000") + 10;
-    bounds.left = bounds.right + sepWidth;
-    bounds.right = bounds.left + width;
-    section->SetFrame(bounds);
+    fLastKeyDownTime = 0;
+    fFocus = index;
+    fHoldValue = _SectionValue(index);
+    Draw(Bounds());
 }
 
 
 float
-TDateEdit::SeparatorWidth() const
+TDateEdit::MinSectionWidth()
 {
-    return 10.0f;
+    return be_plain_font->StringWidth("00");
 }
 
 
-void
-TDateEdit::SectionFocus(uint32 index)
+float
+TDateEdit::SeparatorWidth()
 {
-    fLastKeyDownTime = 0;
-    fFocus = index;
-    fHoldValue = _SectionValue(index);
-    Draw(Bounds());
+    return 10.0f;
 }
 
 
@@ -657 +586 @@
 
     message->AddBool("time", false);
 
-    for (int32 index = 0; index < fSectionList->CountItems(); ++index) {
+    for (int32 index = 0; index < (int)fSectionCount; ++index) {
         uint32 data = _SectionValue(index);
 
         if (fFocus == index)
@@ -687 +616 @@
 TDateEdit::_UpdateFields()
 {
     time_t time = BDateTime(fDate, BTime()).Time_t();
-
+    
     if (fFieldPositions != NULL) {
         free(fFieldPositions);
         fFieldPositions = NULL;
     }
     BLocale::Default()->FormatDate(&fText, fFieldPositions, fFieldPosCount,
         time, B_SHORT_DATE_FORMAT);
-
+    
     if (fFields != NULL) {
         free(fFields);
         fFields = NULL;
-    }
+    }   
     BLocale::Default()->GetDateFields(fFields, fFieldCount,
         B_SHORT_DATE_FORMAT);
 }
@@ -817 +746 @@
 
     return value;
 }
+
+
+float
+TDateEdit::PreferredHeight()
+{
+    font_height fontHeight;
+    GetFontHeight(&fontHeight);
+    return ceilf((fontHeight.ascent + fontHeight.descent) * 1.4);
+}

src/preferences/time/ntp.h

@@ +1 @@
+/*
+ * Copyright 2004, pinc Software. All Rights Reserved.
+ * Distributed under the terms of the MIT license.
+ */
+#ifndef NTP_H
+#define NTP_H
+
+
+#include <SupportDefs.h>
+
+
+extern status_t ntp_update_time(const char *host, 
+    const char** errorString, int32* errorCode);
+
+
+#endif  /* NTP_H */

src/preferences/time/NetworkTimeView.h

@@ +1 @@
+/*
+ * Copyright 2011, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Hamish Morrison <hamish@lavabit.com>
+ *      Axel Dörfler <axeld@pinc-software.de>
+ */
+#ifndef NETWORK_TIME_VIEW_H
+#define NETWORK_TIME_VIEW_H
+
+
+#include <LayoutBuilder.h>
+
+
+class BButton;
+class BCheckBox;
+class BListView;
+class BTextControl;
+class BMessage;
+class BMessenger;
+class BPath;
+class Settings;
+
+
+static const uint32 kMsgNetworkTimeSettings = 'ntst';
+static const uint32 kMsgSetDefaultServer = 'setd';
+static const uint32 kMsgAddServer = 'asrv';
+static const uint32 kMsgRemoveServer = 'rsrv';
+static const uint32 kMsgResetServerList = 'rstl';
+static const uint32 kMsgTryAllServers = 'tras';
+static const uint32 kMsgSynchronizeAtBoot = 'synb';
+static const uint32 kMsgSynchronize = 'sync';
+static const uint32 kMsgStopSynchronization = 'stps';
+static const uint32 kMsgSynchronizationResult = 'syrs';
+static const uint32 kMsgNetworkTimeChange = 'ntch';
+
+
+status_t
+update_time(const Settings& settings, BMessenger* messenger,
+    thread_id* thread);
+
+
+status_t
+update_time(const Settings& settings, const char** errorString,
+    int32* errorCode);
+
+
+class Settings {
+public:
+                            Settings();
+                            ~Settings();
+
+            void            AddServer(const char* server);
+            const char*     GetServer(int32 index) const;
+            void            RemoveServer(const char* server);
+            void            SetDefaultServer(int32 index);
+            int32           GetDefaultServer() const;
+            void            SetTryAllServers(bool boolean);
+            bool            GetTryAllServers() const;
+            void            SetSynchronizeAtBoot(bool boolean);
+            bool            GetSynchronizeAtBoot() const;
+
+            void            ResetServersToDefaults();
+            void            ResetToDefaults();
+            void            Revert();
+            bool            SettingsChanged();
+            
+            status_t        Load();
+            status_t        Save();
+
+private:
+            int32           _GetStringByValue(const char* name,
+                                const char* value);
+            status_t        _GetPath(BPath& path);
+
+            BMessage        fMessage;
+            BMessage        fOldMessage;
+            bool            fWasUpdated;
+};
+
+
+class NetworkTimeView : public BGroupView {
+public:
+                            NetworkTimeView(const char* name);
+        
+    virtual void            MessageReceived(BMessage* message);
+    virtual void            AttachedToWindow();
+    
+            bool            CheckCanRevert();
+private:
+            void            _InitView();
+            void            _UpdateServerList();
+            void            _DoneSynchronizing();
+
+            Settings        fSettings;
+
+            BTextControl*   fServerTextControl;
+            BButton*        fAddButton;
+            BButton*        fRemoveButton;
+            BButton*        fResetButton;
+
+            BListView*      fServerListView;
+            BCheckBox*      fTryAllServersCheckBox;
+            BCheckBox*      fSynchronizeAtBootCheckBox;
+            BButton*        fSynchronizeButton;
+
+            thread_id       fUpdateThread;
+};
+    
+#endif

src/preferences/time/TimeZoneListItem.h

@@ -5 +5 @@
  * Authors:
  *      Adrien Destugues <pulkomandy@pulkomandy.ath.cx>
  */
-
 #ifndef _TIME_ZONE_LIST_ITEM_H
 #define _TIME_ZONE_LIST_ITEM_H
 

src/preferences/time/BaseView.h

@@ -10 +10 @@
 #define _BASE_VIEW_H
 
 
+#include <LayoutBuilder.h>
 #include <Message.h>
-#include <View.h>
 
 
-class TTimeBaseView: public BView {
+class TTimeBaseView : public BGroupView {
 public:
-                                TTimeBaseView(BRect frame, const char* name);
+                                TTimeBaseView(const char* name);
     virtual                     ~TTimeBaseView();
 
     virtual void                Pulse();
@@ -26 +26 @@
 
 private:
             void                _SendNotices();
-
-private:
+            
             BMessage            fMessage;
 };
 

src/preferences/time/ZoneView.h

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 #ifndef ZONE_VIEW_H
 #define ZONE_VIEW_H
 
 
+#include <LayoutBuilder.h>
 #include <TimeZone.h>
-#include <View.h>
 
 
 class BButton;
@@ -24 +25 @@
 class TTZDisplay;
 
 
-class TimeZoneView : public BView {
+class TimeZoneView : public BGroupView {
 public:
-                                TimeZoneView(BRect frame);
+                                TimeZoneView(const char* name);
     virtual                     ~TimeZoneView();
 
     virtual void                AttachedToWindow();
@@ -51 +52 @@
 
             void                _Revert();
 
-private:
             BOutlineListView*   fZoneList;
             BButton*            fSetZone;
             TTZDisplay*         fCurrent;

src/preferences/time/AnalogClock.cpp

@@ -1 +1 @@
 /*
- * Copyright 2004-2009, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -7 +7 @@
  *      Julun <host.haiku@gmx.de>
  *      Stephan Aßmus <superstippi@gmx.de>
  *      Clemens <mail@Clemens-Zeidler.de>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
 #include "AnalogClock.h"
@@ -14 +15 @@
 #include <math.h>
 #include <stdio.h>
 
-#include <Bitmap.h>
+#include <LayoutUtils.h>
 #include <Message.h>
 #include <Window.h>
 
@@ -24 +25 @@
 #define DRAG_DELTA_PHI 0.2
 
 
-class OffscreenClock : public BView {
-public:
-                            OffscreenClock(BRect frame, const char* name,
-                                bool drawSecondHand = true);
-    virtual                 ~OffscreenClock();
+TAnalogClock::TAnalogClock(const char* name,
+    bool drawSecondHand, bool interactive)
+    :
+    BView(name, B_WILL_DRAW | B_DRAW_ON_CHILDREN | B_FRAME_EVENTS),
+    fHours(0),
+    fMinutes(0),
+    fSeconds(0),
+    fDirty(true),
+    fHourDragging(false),
+    fMinuteDragging(false),
+    fDrawSecondHand(drawSecondHand),
+    fInteractive(interactive),
+    fTimeChangeIsOngoing(false)
+{
+    SetFlags(Flags() | B_SUBPIXEL_PRECISE);
+}
 
-            void            SetTime(int32 hour, int32 minute, int32 second);
-            void            GetTime(int32* hour, int32* minute, int32* second);
-            bool            IsDirty() const {   return fDirty;  }
-            void            DrawClock();
 
-            bool            InHourHand(BPoint point);
-            bool            InMinuteHand(BPoint point);
+TAnalogClock::~TAnalogClock()
+{
+}
 
-            void            SetHourHand(BPoint point);
-            void            SetMinuteHand(BPoint point);
 
-            void            SetHourDragging(bool dragging);
-            void            SetMinuteDragging(bool dragging);
+void
+TAnalogClock::MessageReceived(BMessage* message)
+{
+    int32 change;
+    switch (message->what) {
+        case B_OBSERVER_NOTICE_CHANGE:
+            message->FindInt32(B_OBSERVE_WHAT_CHANGE, &change);
+            switch (change) {
+                case H_TM_CHANGED:
+                {
+                    int32 hour = 0;
+                    int32 minute = 0;
+                    int32 second = 0;
+                    if (message->FindInt32("hour", &hour) == B_OK
+                     && message->FindInt32("minute", &minute) == B_OK
+                     && message->FindInt32("second", &second) == B_OK)
+                        SetTime(hour, minute, second);
+                    break;
+                }
+                default:
+                    BView::MessageReceived(message);
+                    break;
+            }
+        break;
+        default:
+            BView::MessageReceived(message);
+            break;
+    }
+}
 
-private:
-            float           _GetPhi(BPoint point);
-            bool            _InHand(BPoint point, int32 ticks, float radius);
-            void            _DrawHands(float x, float y, float radius,
-                                rgb_color hourHourColor,
-                                rgb_color hourMinuteColor,
-                                rgb_color secondsColor, rgb_color knobColor);
 
-            int32           fHours;
-            int32           fMinutes;
-            int32           fSeconds;
-            bool            fDirty;
+void
+TAnalogClock::MouseDown(BPoint point)
+{
+    if(!fInteractive) {
+        BView::MouseDown(point);
+        return;
+    }
+    
+    if (InMinuteHand(point)) {
+        fMinuteDragging = true;
+        fDirty = true;
+        SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
+        Invalidate();
+        return;
+    }
+    if (InHourHand(point)) {
+        fHourDragging = true;
+        fDirty = true;
+        SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
+        Invalidate();
+        return;
+    }
+}
 
-            float           fCenterX;
-            float           fCenterY;
-            float           fRadius;
 
-            bool            fHourDragging;
-            bool            fMinuteDragging;
-            
-            bool            fDrawSecondHand;
-};
+void
+TAnalogClock::MouseUp(BPoint point)
+{
+    if(!fInteractive) {
+        BView::MouseUp(point);
+        return;
+    }
+    
+    if (fHourDragging || fMinuteDragging) {
+        int32 hour, minute, second;
+        GetTime(&hour, &minute, &second);
+        BMessage message(H_USER_CHANGE);
+        message.AddBool("time", true);
+        message.AddInt32("hour", hour);
+        message.AddInt32("minute", minute);
+        Window()->PostMessage(&message);
+        fTimeChangeIsOngoing = true;
+    }
+    fHourDragging = false;
+    fDirty = true;
+    fMinuteDragging = false;
+    fDirty = true;
+}
 
 
-OffscreenClock::OffscreenClock(BRect frame, const char* name,
-    bool drawSecondHand)
-    :
-    BView(frame, name, B_FOLLOW_NONE, B_WILL_DRAW),
-    fHours(0),
-    fMinutes(0),
-    fSeconds(0),
-    fDirty(true),
-    fHourDragging(false),
-    fMinuteDragging(false),
-    fDrawSecondHand(drawSecondHand)
+void
+TAnalogClock::MouseMoved(BPoint point, uint32 transit, const BMessage* message)
 {
-    SetFlags(Flags() | B_SUBPIXEL_PRECISE);
+    if(!fInteractive) {
+        BView::MouseMoved(point, transit, message);
+        return;
+    }
 
-    BRect bounds = Bounds();
-    fCenterX = floorf((bounds.left + bounds.right) / 2 + 0.5) + 0.5;
-    fCenterY = floorf((bounds.top + bounds.bottom) / 2 + 0.5) + 0.5;
-        // + 0.5 is for the offset to pixel centers
-        // (important when drawing with B_SUBPIXEL_PRECISE)
+    if (fMinuteDragging)
+        SetMinuteHand(point);
+    if (fHourDragging)
+        SetHourHand(point);
 
-    fRadius = floorf((MIN(bounds.Width(), bounds.Height()) / 2.0)) - 2.5;
-    fRadius -= 3;
+    Invalidate();
 }
 
 
-OffscreenClock::~OffscreenClock()
+void
+TAnalogClock::Draw(BRect /*updateRect*/)
 {
+    if (fDirty)
+        DrawClock();
 }
 
 
 void
-OffscreenClock::SetTime(int32 hour, int32 minute, int32 second)
+TAnalogClock::SetTime(int32 hour, int32 minute, int32 second)
 {
+    // don't set the time if the hands are in a drag action
+    if (fHourDragging || fMinuteDragging || fTimeChangeIsOngoing)
+        return;
+    
     if (fHours == hour && fMinutes == minute && fSeconds == second)
         return;
 
@@ -109 +169 @@
     fSeconds = second;
 
     fDirty = true;
+
+    BWindow* window = Window();
+    if (window && window->Lock()) {
+        Invalidate();
+        Window()->Unlock();
+    }
 }
 
 
+bool
+TAnalogClock::IsChangingTime()
+{
+    return fTimeChangeIsOngoing;
+}
+
+
 void
-OffscreenClock::GetTime(int32* hour, int32* minute, int32* second)
+TAnalogClock::ChangeTimeFinished()
 {
+    fTimeChangeIsOngoing = false;
+}
+
+
+void
+TAnalogClock::GetTime(int32* hour, int32* minute, int32* second)
+{
     *hour = fHours;
     *minute = fMinutes;
     *second = fSeconds;
@@ -122 +202 @@
 
 
 void
-OffscreenClock::DrawClock()
+TAnalogClock::DrawClock()
 {
     if (!LockLooper())
         return;
@@ -132 +212 @@
     rgb_color background = ui_color(B_PANEL_BACKGROUND_COLOR);
     SetHighColor(background);
     FillRect(bounds);
-
-
+    
     bounds.Set(fCenterX - fRadius, fCenterY - fRadius,
         fCenterX + fRadius, fCenterY + fRadius);
 
@@ -207 +286 @@
 }
 
 
+void
+TAnalogClock::FrameResized(float, float)
+{
+    BRect bounds = Bounds();
+
+    // + 0.5 is for the offset to pixel centers
+    // (important when drawing with B_SUBPIXEL_PRECISE)
+    fCenterX = floorf((bounds.left + bounds.right) / 2 + 0.5) + 0.5;
+    fCenterY = floorf((bounds.top + bounds.bottom) / 2 + 0.5) + 0.5;
+    fRadius = floorf((MIN(bounds.Width(), bounds.Height()) / 2.0)) - 2.5;
+    fRadius -= 3;
+}
+
+
+BSize
+TAnalogClock::MaxSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
+        BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
+}
+
+
+BSize
+TAnalogClock::MinSize()
+{
+    return BSize(0, 0);
+}
+
+
+BSize
+TAnalogClock::PreferredSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitPreferredSize(),
+        BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
+}
+
+
 bool
-OffscreenClock::InHourHand(BPoint point)
+TAnalogClock::InHourHand(BPoint point)
 {
     int32 ticks = fHours;
     if (ticks > 12)
@@ -222 +338 @@
 
 
 bool
-OffscreenClock::InMinuteHand(BPoint point)
+TAnalogClock::InMinuteHand(BPoint point)
 {
     return _InHand(point, fMinutes, fRadius * 0.9);
 }
 
 
 void
-OffscreenClock::SetHourHand(BPoint point)
+TAnalogClock::SetHourHand(BPoint point)
 {
     point.x -= fCenterX;
     point.y -= fCenterY;
@@ -247 +363 @@
 
 
 void
-OffscreenClock::SetMinuteHand(BPoint point)
+TAnalogClock::SetMinuteHand(BPoint point)
 {
     point.x -= fCenterX;
     point.y -= fCenterY;
@@ -260 +376 @@
 }
 
 
-void
-OffscreenClock::SetHourDragging(bool dragging)
-{
-    fHourDragging = dragging;
-    fDirty = true;
-}
-
-
-void
-OffscreenClock::SetMinuteDragging(bool dragging)
-{
-    fMinuteDragging = dragging;
-    fDirty = true;
-}
-
-
 float
-OffscreenClock::_GetPhi(BPoint point)
+TAnalogClock::_GetPhi(BPoint point)
 {
     if (point.x == 0 && point.y < 0)
         return 2 * M_PI;
@@ -302 +402 @@
 
 
 bool
-OffscreenClock::_InHand(BPoint point, int32 ticks, float radius)
+TAnalogClock::_InHand(BPoint point, int32 ticks, float radius)
 {
     point.x -= fCenterX;
     point.y -= fCenterY;
@@ -323 +423 @@
 
 
 void
-OffscreenClock::_DrawHands(float x, float y, float radius,
-    rgb_color hourColor,
-    rgb_color minuteColor,
-    rgb_color secondsColor,
-    rgb_color knobColor)
+TAnalogClock::_DrawHands(float x, float y, float radius,
+    rgb_color hourColor, rgb_color minuteColor,
+    rgb_color secondsColor, rgb_color knobColor)
 {
     float offsetX;
     float offsetY;
@@ -361 +459 @@
     SetHighColor(knobColor);
     FillEllipse(BPoint(x, y), radius * 0.06, radius * 0.06);
 }
-
-
-//  #pragma mark -
-
-
-TAnalogClock::TAnalogClock(BRect frame, const char* name,
-    bool drawSecondHand, bool interactive)
-    :
-    BView(frame, name, B_FOLLOW_NONE, B_WILL_DRAW | B_DRAW_ON_CHILDREN),
-    fBitmap(NULL),
-    fClock(NULL),
-    fDrawSecondHand(drawSecondHand),
-    fInteractive(interactive),
-    fDraggingHourHand(false),
-    fDraggingMinuteHand(false),
-    fTimeChangeIsOngoing(false)
-{
-    _InitView(frame);
-}
-
-
-TAnalogClock::~TAnalogClock()
-{
-    delete fBitmap;
-}
-
-
-void
-TAnalogClock::_InitView(BRect rect)
-{
-    fClock = new OffscreenClock(Bounds(), "offscreen", fDrawSecondHand);
-    fBitmap = new BBitmap(Bounds(), B_RGB32, true);
-    fBitmap->Lock();
-    fBitmap->AddChild(fClock);
-    fBitmap->Unlock();
-}
-
-
-void
-TAnalogClock::AttachedToWindow()
-{
-    SetViewColor(B_TRANSPARENT_COLOR);
-}
-
-
-void
-TAnalogClock::MessageReceived(BMessage* message)
-{
-    int32 change;
-    switch (message->what) {
-        case B_OBSERVER_NOTICE_CHANGE:
-            message->FindInt32(B_OBSERVE_WHAT_CHANGE, &change);
-            switch (change) {
-                case H_TM_CHANGED:
-                {
-                    int32 hour = 0;
-                    int32 minute = 0;
-                    int32 second = 0;
-                    if (message->FindInt32("hour", &hour) == B_OK
-                     && message->FindInt32("minute", &minute) == B_OK
-                     && message->FindInt32("second", &second) == B_OK)
-                        SetTime(hour, minute, second);
-                    break;
-                }
-                default:
-                    BView::MessageReceived(message);
-                    break;
-            }
-        break;
-        default:
-            BView::MessageReceived(message);
-            break;
-    }
-}
-
-
-void
-TAnalogClock::MouseDown(BPoint point)
-{
-    if(!fInteractive) {
-        BView::MouseDown(point);
-        return;
-    }
-    
-    fDraggingMinuteHand = fClock->InMinuteHand(point);
-    if (fDraggingMinuteHand) {
-        fClock->SetMinuteDragging(true);
-        SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
-        Invalidate();
-        return;
-    }
-    fDraggingHourHand = fClock->InHourHand(point);
-    if (fDraggingHourHand) {
-        fClock->SetHourDragging(true);
-        SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
-        Invalidate();
-        return;
-    }
-}
-
-
-void
-TAnalogClock::MouseUp(BPoint point)
-{
-    if(!fInteractive) {
-        BView::MouseUp(point);
-        return;
-    }
-    
-    if (fDraggingHourHand || fDraggingMinuteHand) {
-        int32 hour, minute, second;
-        fClock->GetTime(&hour, &minute, &second);
-        BMessage message(H_USER_CHANGE);
-        message.AddBool("time", true);
-        message.AddInt32("hour", hour);
-        message.AddInt32("minute", minute);
-        Window()->PostMessage(&message);
-        fTimeChangeIsOngoing = true;
-    }
-    fDraggingHourHand = false;
-    fDraggingMinuteHand = false;
-    fClock->SetMinuteDragging(false);
-    fClock->SetHourDragging(false);
-}
-
-
-void
-TAnalogClock::MouseMoved(BPoint point, uint32 transit, const BMessage* message)
-{
-    if(!fInteractive) {
-        BView::MouseMoved(point, transit, message);
-        return;
-    }
-
-    if (fDraggingMinuteHand)
-        fClock->SetMinuteHand(point);
-    if (fDraggingHourHand)
-        fClock->SetHourHand(point);
-
-    Invalidate();
-}
-
-
-void
-TAnalogClock::Draw(BRect /*updateRect*/)
-{
-    if (fBitmap) {
-        if (fClock->IsDirty())
-            fClock->DrawClock();
-        DrawBitmap(fBitmap, BPoint(0, 0));
-    }
-}
-
-
-void
-TAnalogClock::SetTime(int32 hour, int32 minute, int32 second)
-{
-    // don't set the time if the hands are in a drag action
-    if (fDraggingHourHand || fDraggingMinuteHand || fTimeChangeIsOngoing)
-        return;
-
-    if (fClock)
-        fClock->SetTime(hour, minute, second);
-
-    BWindow* window = Window();
-    if (window && window->Lock()) {
-        Invalidate();
-        Window()->Unlock();
-    }
-}
-
-
-void
-TAnalogClock::ChangeTimeFinished()
-{
-    fTimeChangeIsOngoing = false;
-}

src/preferences/time/SectionEdit.h

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
- *
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 #ifndef _SECTION_EDIT_H
 #define _SECTION_EDIT_H
@@ -18 +18 @@
 class BList;
 
 
-class TSection {
+class TSectionEdit : public BControl {
 public:
-                                TSection(BRect frame);
-
-            BRect               Bounds() const;
-            void                SetFrame(BRect frame);
-            BRect               Frame() const;
-
-private:
-            BRect               fFrame;
-};
-
-
-class TSectionEdit: public BControl {
-public:
-                                TSectionEdit(BRect frame, const char* name,
+                                TSectionEdit(const char* name,
                                     uint32 sections);
     virtual                     ~TSectionEdit();
 
@@ -43 +30 @@
     virtual void                MakeFocus(bool focused = true);
     virtual void                KeyDown(const char* bytes, int32 numBytes);
 
+            BSize               MaxSize();
+            BSize               MinSize();
+            BSize               PreferredSize();
+
             uint32              CountSections() const;
             int32               FocusIndex() const;
             BRect               SectionArea() const;
 
 protected:
-    virtual void                InitView();
-
-    // hooks
     virtual void                DrawBorder(const BRect& updateRect);
-    virtual void                DrawSection(uint32 index, bool isFocus) {}
-    virtual void                DrawSeparator(uint32 index) {}
+    virtual void                DrawSection(uint32 index, BRect bounds,
+                                    bool isFocus) {}
+    virtual void                DrawSeparator(uint32 index, BRect bounds) {}
 
+            BRect               FrameForSection(uint32 index);
+            BRect               FrameForSeparator(uint32 index);
+
     virtual void                SectionFocus(uint32 index) {}
     virtual void                SectionChange(uint32 index, uint32 value) {}
     virtual void                SetSections(BRect area) {}
-    virtual float               SeparatorWidth() const;
-
+    
+    virtual float               SeparatorWidth() = 0;
+    virtual float               MinSectionWidth() = 0;
+    virtual float               PreferredHeight() = 0;
+    
     virtual void                DoUpPress() {}
     virtual void                DoDownPress() {}
 
     virtual void                DispatchMessage();
     virtual void                BuildDispatch(BMessage* message) = 0;
-
-protected:
-            BList*              fSectionList;
-
+            
             BRect               fUpRect;
             BRect               fDownRect;
-            BRect               fSectionArea;
 
             int32               fFocus;
             uint32              fSectionCount;

src/preferences/time/TZDisplay.cpp

@@ -1 +1 @@
 /*
- * Copyright 2004-2007, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Andrew McCall <mccall@@digitalparadise.co.uk>
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
- *
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 
+#include "TZDisplay.h"
+
 #include <stdio.h>
 
-#include "TZDisplay.h"
+#include <LayoutUtils.h>
 
 
-namespace {
-    float _FontHeight()
-    {
-        font_height fontHeight;
-        be_plain_font->GetHeight(&fontHeight);
-        float height = ceil(fontHeight.descent + fontHeight.ascent
-            + fontHeight.leading);
-        return height;
-    }
-}
 
-
-TTZDisplay::TTZDisplay(BRect frame, const char* name, const char* label)
-    : BView(frame, name, B_FOLLOW_NONE, B_WILL_DRAW),
-      fLabel(label),
-      fText(""),
-      fTime("")
+TTZDisplay::TTZDisplay(const char* name, const char* label)
+    :
+    BView(name, B_WILL_DRAW),
+    fLabel(label),
+    fText(""),
+    fTime("")
 {
 }
 
@@ -51 +43 @@
 void
 TTZDisplay::ResizeToPreferred()
 {
-    ResizeTo(Bounds().Width(), _FontHeight() * 2.0 + 4.0);
+    BSize size = _CalcPrefSize();
+    ResizeTo(size.width, size.height);
 }
 
 
 void
-TTZDisplay::Draw(BRect /* updateRect */)
+TTZDisplay::Draw(BRect)
 {
     SetLowColor(ViewColor());
 
     BRect bounds = Bounds();
     FillRect(Bounds(), B_SOLID_LOW);
+    
+    font_height height;
+    GetFontHeight(&height);
+    float fontHeight = ceilf(height.descent + height.ascent +
+        height.leading);
 
-    float fontHeight = _FontHeight();
-
-    BPoint pt(bounds.left + 2.0, fontHeight / 2.0 + 2.0);
+    BPoint pt(bounds.left, ceilf(bounds.top + height.ascent));
     DrawString(fLabel.String(), pt);
 
     pt.y += fontHeight;
     DrawString(fText.String(), pt);
 
     pt.y -= fontHeight;
-    pt.x = bounds.right - StringWidth(fTime.String()) - 2.0;
+    pt.x = bounds.right - StringWidth(fTime.String());
     DrawString(fTime.String(), pt);
 }
 
@@ -89 +85 @@
 {
     fLabel.SetTo(label);
     Invalidate();
+    InvalidateLayout();
 }
 
 
@@ -104 +101 @@
 {
     fText.SetTo(text);
     Invalidate();
+    InvalidateLayout();
 }
 
 
@@ -119 +117 @@
 {
     fTime.SetTo(time);
     Invalidate();
+    InvalidateLayout();
 }
 
+
+BSize
+TTZDisplay::MaxSize()
+{
+    BSize size = _CalcPrefSize();
+    size.width = B_SIZE_UNLIMITED;
+    
+    return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
+        size);
+}
+
+
+BSize
+TTZDisplay::MinSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitMinSize(),
+        _CalcPrefSize());
+}
+
+
+BSize
+TTZDisplay::PreferredSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitPreferredSize(),
+        _CalcPrefSize());
+}
+
+
+BSize
+TTZDisplay::_CalcPrefSize()
+{
+    font_height fontHeight;
+    GetFontHeight(&fontHeight);
+    
+    BSize size;
+    size.height = 2 * ceilf(fontHeight.ascent + fontHeight.descent +
+        fontHeight.leading);
+    
+    float firstLine = ceilf(StringWidth(fLabel.String()) +
+        StringWidth(" ") + StringWidth(fTime.String()));
+    float secondLine = ceilf(StringWidth(fText.String()));
+    size.width = firstLine > secondLine ? firstLine : secondLine;
+    return size;
+}

src/preferences/time/TimeSettings.h

@@ -29 +29 @@
 
 
 #endif  // _TIME_SETTINGS_H
-

src/preferences/time/TimeWindow.h

@@ -5 +5 @@
  * Authors:
  *      Andrew McCall <mccall@@digitalparadise.co.uk>
  *      Julun <host.haiku@gmx.de>
- *
  */
 #ifndef _TIME_WINDOW_H
 #define _TIME_WINDOW_H
@@ -18 +17 @@
 class DateTimeView;
 class TTimeBaseView;
 class TimeZoneView;
+class NetworkTimeView;
 
 
 class TTimeWindow : public BWindow {
 public:
-                                TTimeWindow(BRect rect);
+                                TTimeWindow();
     virtual                     ~TTimeWindow();
 
     virtual bool                QuitRequested();
     virtual void                MessageReceived(BMessage* message);
-            void                SetRevertStatus();
 
 private:
             void                _InitWindow();
             void                _AlignWindow();
-
             void                _SendTimeChangeFinished();
+            void                _SetRevertStatus();
 
-private:
             TTimeBaseView*      fBaseView;
             DateTimeView*       fDateTimeView;
             TimeZoneView*       fTimeZoneView;
+            NetworkTimeView*    fNetworkTimeView;
             BButton*            fRevertButton;
 };
 
 
 #endif  // _TIME_WINDOW_H
-

src/preferences/time/TimeMessages.h

@@ -43 +43 @@
 // clicked on revert button
 const uint32 kMsgRevert = 'rvrt';
 
+// something was changed
+const uint32 kMsgChange = 'chng';
+
 // change time finished
 const uint32 kChangeTimeFinished = 'tcfi';
 
 
 #endif  // _TIME_MESSAGES_H
-

src/preferences/time/DateTimeView.h

@@ -1 +1 @@
 /*
- * Copyright 2004-2010, Haiku, Inc. All Rights Reserved.
+ * Copyright 2004-2011, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -7 +7 @@
  *      Mike Berg <mike@berg-net.us>
  *      Julun <host.haiku@gmx.de>
  *      Philippe Saint-Pierre <stpere@gmail.com>
+ *      Hamish Morrison <hamish@lavabit.com>
  */
 #ifndef _DATE_TIME_VIEW_H
 #define _DATE_TIME_VIEW_H
 
 
-#include <View.h>
+#include <LayoutBuilder.h>
 
 
 class TDateEdit;
@@ -27 +28 @@
 using BPrivate::BCalendarView;
 
 
-class DateTimeView : public BView {
+class DateTimeView : public BGroupView {
 public:
-                                DateTimeView(BRect frame);
+                                DateTimeView(const char* name);
     virtual                     ~DateTimeView();
 
     virtual void                AttachedToWindow();
@@ -48 +49 @@
             void                _Revert();
             time_t              _PrefletUptime() const;
 
-private:
             BRadioButton*       fLocalTime;
             BRadioButton*       fGmtTime;
             TDateEdit*          fDateEdit;

src/kits/shared/CalendarView.cpp

@@ -11 +11 @@
 
 #include <stdlib.h>
 
+#include <LayoutUtils.h>
 #include <Window.h>
 
 
@@ -72 +73 @@
 }
 
 
+BCalendarView::BCalendarView(const char* name, uint32 flags)
+    :
+    BView(name, flags),
+    BInvoker(),
+    fSelectionMessage(NULL),
+    fDay(0),
+    fYear(0),
+    fMonth(0),
+    fFocusChanged(false),
+    fSelectionChanged(false),
+    fWeekStart(B_WEEK_START_SUNDAY),
+    fDayNameHeaderVisible(true),
+    fWeekNumberHeaderVisible(true)
+{
+    _InitObject();
+}
+
+
 BCalendarView::~BCalendarView()
 {
     SetSelectionMessage(NULL);
@@ -559 +578 @@
 }
 
 
+BSize
+BCalendarView::MaxSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
+        BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
+}
+
+
+BSize
+BCalendarView::MinSize()
+{
+    float width, height;
+    _GetPreferredSize(&width, &height);
+    return BLayoutUtils::ComposeSize(ExplicitMinSize(),
+        BSize(width, height));
+}
+
+
+BSize
+BCalendarView::PreferredSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitPreferredSize(),
+        MinSize());
+}
+
+
 int32
 BCalendarView::Day() const
 {

headers/private/shared/CalendarView.h

@@ -36 +36 @@
                                 BCalendarView(BRect frame, const char *name, week_start start,
                                     uint32 resizeMask = B_FOLLOW_LEFT | B_FOLLOW_TOP,
                                     uint32 flags = B_WILL_DRAW | B_FRAME_EVENTS | B_NAVIGABLE);
+                                
+                                BCalendarView(const char* name,
+                                    uint32 flags = B_WILL_DRAW | B_FRAME_EVENTS | B_NAVIGABLE);
 
         virtual                 ~BCalendarView();
 
@@ -88 +91 @@
 
         virtual void            ResizeToPreferred();
         virtual void            GetPreferredSize(float *width, float *height);
+        
+        virtual BSize           MaxSize();
+        virtual BSize           MinSize();
+        virtual BSize           PreferredSize();
 
         int32                   Day() const;
         int32                   Year() const;