Ticket #2412: time_pref_net.patch

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 <Alert.h>
+#include <Application.h>
+#include <Button.h>
+#include <CheckBox.h>
+#include <File.h>
+#include <FindDirectory.h>
+#include <MenuField.h>
+#include <MenuItem.h>
+#include <Path.h>
+#include <PopUpMenu.h>
+#include <View.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include "ntp.h"
+
+
+class MessengerMonitor : public Monitor {
+    public:
+        MessengerMonitor(BLooper& looper)
+            :
+            fLooper(looper)
+        {
+        }
+
+        virtual void
+        Done(status_t status)
+        {
+            BMessage message(kMsgStatusUpdate);
+            message.AddInt32("status", status);
+
+            fLooper.PostMessage(&message);
+            fLooper.PostMessage(kMsgStopSynchronization);
+        }
+
+    private:
+        virtual void
+        update(float progress, const char *text, va_list args)
+        {
+            BMessage message(kMsgStatusUpdate);
+            if (progress != -1.f)
+                message.AddFloat("progress", progress);
+
+            if (text != NULL) {
+                char buffer[2048];
+                vsnprintf(buffer, sizeof(buffer), text, args);
+                message.AddString("message", buffer);
+            }
+
+            fLooper.PostMessage(&message);
+        }
+
+        BLooper& fLooper;
+};
+
+
+class UpdateLooper : public BLooper {
+    public:
+        UpdateLooper(const BMessage &settings, Monitor *monitor);
+
+        void MessageReceived(BMessage *message);
+
+    private:
+        const BMessage  &fSettings;
+        Monitor         *fMonitor;
+};
+
+
+UpdateLooper::UpdateLooper(const BMessage &settings, Monitor *monitor)
+    : BLooper("update looper"),
+    fSettings(settings),
+    fMonitor(monitor)
+{
+    PostMessage(kMsgSynchronize);
+}
+
+
+void
+UpdateLooper::MessageReceived(BMessage *message)
+{
+    if (message->what != kMsgSynchronize)
+        return;
+
+    update_time(fSettings, fMonitor);
+}
+
+
+status_t
+adopt_int32(const BMessage &from, BMessage &to,
+    const char *name, bool &updated)
+{
+    int32 value;
+    if (from.FindInt32(name, &value) != B_OK)
+        return B_ENTRY_NOT_FOUND;
+
+    int32 original;
+    if (to.FindInt32(name, &original) == B_OK) {
+        if (value == original)
+            return B_OK;
+
+        updated = true;
+        return to.ReplaceInt32(name, value);
+    }
+
+    updated = true;
+    return to.AddInt32(name, value);
+}
+
+
+status_t
+adopt_bool(const BMessage &from, BMessage &to,
+    const char *name, bool &updated)
+{
+    bool value;
+    if (from.FindBool(name, &value) != B_OK)
+        return B_ENTRY_NOT_FOUND;
+
+    bool original;
+    if (to.FindBool(name, &original) == B_OK) {
+        if (value == original)
+            return B_OK;
+
+        updated = true;
+        return to.ReplaceBool(name, value);
+    }
+
+    updated = true;
+    return to.AddBool(name, value);
+}
+
+
+status_t
+adopt_rect(const BMessage &from, BMessage &to,
+    const char *name, bool &updated)
+{
+    BRect rect;
+    if (from.FindRect(name, &rect) != B_OK)
+        return B_ENTRY_NOT_FOUND;
+
+    BRect original;
+    if (to.FindRect(name, &original) == B_OK) {
+        if (rect == original)
+            return B_OK;
+
+        updated = true;
+        return to.ReplaceRect(name, rect);
+    }
+
+    updated = true;
+    return to.AddRect(name, rect);
+}
+
+
+Settings::Settings()
+    :
+    fMessage(kMsgNetworkTimeSettings),
+    fWasUpdated(false)
+{
+    ResetToDefaults();
+    Load();
+}
+
+
+Settings::~Settings()
+{
+    if (fWasUpdated)
+        Save();
+}
+
+
+void
+Settings::CopyMessage(BMessage &message) const
+{
+    message = fMessage;
+}
+
+
+const BMessage &
+Settings::Message() const
+{
+    return fMessage;
+}
+
+
+void
+Settings::UpdateFrom(BMessage &message)
+{
+    if (message.HasBool("reset servers")) {
+        fMessage.RemoveName("server");
+        fWasUpdated = true;
+    }
+
+    if (message.HasString("server")) {
+        // remove old servers
+        fMessage.RemoveName("server");
+
+        const char *server;
+        int32 index = 0;
+        while (message.FindString("server", index++, &server) == B_OK) {
+            fMessage.AddString("server", server);
+        }
+
+        fWasUpdated = true;
+    }
+
+    adopt_int32(message, fMessage, "default server", fWasUpdated);
+
+    adopt_bool(message, fMessage, "synchronize at boot", fWasUpdated);
+    adopt_bool(message, fMessage, "try all servers", fWasUpdated);
+    adopt_bool(message, fMessage, "choose default server", fWasUpdated);
+
+    adopt_rect(message, fMessage, "edit servers frame", fWasUpdated);
+}
+
+
+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);
+
+    fMessage.AddRect("status frame", BRect(0, 0, 300, 150));
+    fMessage.AddRect("edit servers frame", BRect(0, 0, 250, 250));
+}
+
+
+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;
+    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);
+}
+
+
+status_t
+Settings::GetPath(BPath &path)
+{
+    status_t status;
+    if ((status = find_directory(B_USER_SETTINGS_DIRECTORY, &path)) != 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),
+    fEditServerListWindow(NULL),
+    fUpdateThread(-1),
+    fStatusString(""),
+    fSettings()
+{
+    fSettings.Load();
+    _InitView();
+}
+
+
+void
+NetworkTimeView::_InitView()
+{
+    SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
+
+    BPopUpMenu* menu = new BPopUpMenu("serverMenu");
+    fServerListMenuField = new BMenuField("serverList", "Use server:", menu);
+    _UpdateServerListMenu();
+    fEditServerListButton = new BButton("editServerList", "Edit Server List",
+        new BMessage(kMsgEditServerList));
+    
+    fTryAllServersCheckBox = new BCheckBox("tryAllServers", "Try all servers",
+        new BMessage(kMsgTryAllServers));
+    bool boolean;
+    if (fSettings.Message().FindBool("try all servers", &boolean) == B_OK)
+        fTryAllServersCheckBox->SetValue(boolean);
+    
+    fSynchronizeAtBootCheckBox = new BCheckBox("autoUpdate", 
+        "Synchronize at boot", new BMessage(kMsgSynchronizeAtBoot));
+    if (fSettings.Message().FindBool("synchronize at boot", &boolean) == B_OK)
+        fSynchronizeAtBootCheckBox->SetValue(boolean);
+    fSynchronizeButton = new BButton("update", "Synchronize now",
+        new BMessage(kMsgSynchronize));
+    
+    BLayoutBuilder::Group<>(this)
+        .AddGroup(B_HORIZONTAL)
+            .Add(fServerListMenuField)
+            .Add(fEditServerListButton)
+        .End()
+        .Add(fTryAllServersCheckBox)
+        .Add(fSynchronizeAtBootCheckBox)
+        .AddGroup(B_HORIZONTAL)
+            .AddGlue()
+            .Add(fSynchronizeButton)
+        .End()
+        .SetInsets(5, 5, 5, 5);
+}
+
+
+void
+NetworkTimeView::_UpdateServerListMenu()
+{
+    while (fServerListMenuField->Menu()->RemoveItem(0L) != NULL);
+    
+    const char* server;
+    int32 index = 0;
+    while (fSettings.Message().FindString("server", index++, &server)
+        == B_OK)
+        fServerListMenuField->Menu()->AddItem(
+            new BMenuItem(server, new BMessage(kMsgDefaultServer)));
+    
+    int32 defaultServer;
+    if (fSettings.Message().FindInt32("default server", &defaultServer)
+        != B_OK)
+        defaultServer = 0;
+    fServerListMenuField->Menu()->ItemAt(defaultServer)->SetMarked(true);
+}
+
+
+void
+NetworkTimeView::MessageReceived(BMessage* message)
+{
+    switch (message->what) {
+        case kMsgTryAllServers:
+        {
+            BMessage update(kMsgUpdateSettings);
+            update.AddBool("try all servers",
+                fTryAllServersCheckBox->Value());
+            Looper()->PostMessage(&update);
+            break;
+        }
+        
+        case kMsgSynchronizeAtBoot:
+        {
+            BMessage update(kMsgUpdateSettings);
+            update.AddBool("synchronize at boot", 
+                fSynchronizeAtBootCheckBox->Value());
+            Looper()->PostMessage(&update);
+            break;
+        }
+        
+        case kMsgSettingsUpdated:
+        {
+            if (message->HasString("server"))
+                _UpdateServerListMenu();
+            else {
+                int32 defaultServer;
+                if (fSettings.Message()
+                    .FindInt32("default server", &defaultServer) != B_OK)
+                    defaultServer = 0;
+                fServerListMenuField->Menu()->ItemAt(defaultServer)
+                    ->SetMarked(true);
+            }
+            bool boolean;
+            if (message->FindBool("synchronize at boot", &boolean) == B_OK)
+                fSynchronizeAtBootCheckBox->SetValue(boolean);
+            if (message->FindBool("try all servers", &boolean) == B_OK)
+                fTryAllServersCheckBox->SetValue(boolean);
+            break;
+        }
+        
+        case kMsgUpdateSettings:
+        {
+            fSettings.UpdateFrom(*message);
+            message->what = kMsgSettingsUpdated;
+            BWindow *window;
+            int32 index = 0;
+
+            while ((window = be_app->WindowAt(index++)) != NULL)
+                window->PostMessage(message);
+            break;
+        }
+
+        case kMsgResetServerList:
+        {
+            fSettings.ResetServersToDefaults();
+
+            BMessage updated = fSettings.Message();
+            updated.what = kMsgSettingsUpdated;
+
+            BWindow *window;
+            int32 index = 0;
+            while ((window = be_app->WindowAt(index++)) != NULL)
+                window->PostMessage(message);
+            
+            break;
+        }
+
+        case kMsgEditServerList:
+            if (fEditServerListWindow == NULL) {
+                BRect rect(0, 0, 250, 250);
+                fEditServerListWindow = new EditServerListWindow(rect,
+                    fSettings.Message(), Looper());
+            }
+            fEditServerListWindow->Show();
+            break;
+            
+        case kMsgEditServerListWindowClosed:
+            fEditServerListWindow = NULL;
+            break;
+
+        case kMsgDefaultServer:
+        {
+            int32 index;
+            if (message->FindInt32("index", &index) != B_OK)
+                break;
+            BMessage update(kMsgUpdateSettings);
+            update.AddInt32("default server", index);
+            Looper()->PostMessage(&update);
+            break;
+        }
+
+        case kMsgStopSynchronization:
+            if (fUpdateThread >= B_OK)
+                kill_thread(fUpdateThread);
+            fUpdateThread = -1;
+
+            fSynchronizeButton->SetLabel("Synchronize");
+            fSynchronizeButton->Message()->what = kMsgSynchronize;
+            break;
+
+        case kMsgSynchronize:
+        {
+            if (fUpdateThread >= B_OK)
+                break;
+
+            MessengerMonitor* monitor = new MessengerMonitor(*Looper());
+            update_time(fSettings.Message(), monitor, &fUpdateThread);
+            fSynchronizeButton->SetLabel("Stop");
+            fSynchronizeButton->Message()->what = kMsgStopSynchronization;
+            break;
+        }
+        
+        case kMsgStatusUpdate:
+        {
+            message->FindString("message", &fStatusString);
+            status_t status;
+            if (message->FindInt32("status", (int32 *)&status) == B_OK) {
+                if (status != B_OK) {
+                    (new BAlert("Time", "Error synchronizing!", "OK"))->Go();
+                }
+            }
+            break;
+        }
+    }
+}
+
+
+status_t
+update_time(const BMessage &settings, Monitor *monitor)
+{
+    int32 defaultServer;
+    if (settings.FindInt32("default server", &defaultServer) != B_OK)
+        defaultServer = 0;
+
+    status_t status = B_ENTRY_NOT_FOUND;
+    const char *server;
+    if (settings.FindString("server", defaultServer, &server) == B_OK)
+        status = ntp_update_time(server, monitor);
+
+    // try other servers if we should
+    if (status != B_OK && settings.FindBool("try all servers")) {
+        for (int32 index = 0; ; index++) {
+            if (index == defaultServer)
+                index++;
+            if (settings.FindString("server", index, &server) != B_OK)
+                break;
+
+            status = ntp_update_time(server, monitor);
+            if (status == B_OK) {
+                if (be_app != NULL && settings.FindBool("choose default server")) {
+                    BMessage update(kMsgUpdateSettings);
+                    update.AddInt32("default server", index);
+                    be_app->PostMessage(&update);
+                }
+                break;
+            }
+        }
+    }
+
+    if (monitor != NULL)
+        monitor->Done(status);
+
+    delete monitor;
+    return status;
+}
+
+
+status_t
+update_time(const BMessage &settings, Monitor *monitor, thread_id *_asyncThread)
+{
+    if (_asyncThread != NULL) {
+        BLooper *looper = new UpdateLooper(settings, monitor);
+        *_asyncThread = looper->Run();
+        return B_OK;
+    }
+
+    return update_time(settings, monitor);
+}

src/preferences/time/EditServerListWindow.h

@@ +1 @@
+/*
+ * Copyright 2004, pinc Software. All Rights Reserved.
+ * Distributed under the terms of the MIT license.
+ */
+#ifndef EDIT_SERVER_LIST_WINDOW_H
+#define EDIT_SERVER_LIST_WINDOW_H
+
+
+#include <Window.h>
+
+class BTextView;
+
+
+class EditServerListWindow : public BWindow {
+    public:
+        EditServerListWindow(BRect position, const BMessage &settings, BLooper* looper);
+        virtual ~EditServerListWindow();
+
+        virtual bool QuitRequested();
+        virtual void MessageReceived(BMessage *message);
+
+    private:
+        void UpdateDefaultServerView(const BMessage &message);
+        void UpdateServerView(const BMessage &message);
+
+        void UpdateServerList();
+
+        const BMessage  &fSettings;
+        BTextView       *fServerView;
+        
+        BLooper         *fLooper;
+};
+
+#endif  /* EDIT_SERVER_LIST_WINDOW_H */

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);
 }
 
 

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>
@@ -77 +77 @@
 
 
 
-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),
@@ -173 +173 @@
             break;
 
         default:
-            BView::MessageReceived(message);
+            BGroupView::MessageReceived(message);
             break;
     }
 }
@@ -233 +233 @@
 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());
+    
+    BLayoutBuilder::Group<>(this)
+        .Add(scrollList)
+        .AddGroup(B_VERTICAL, 5)
+            .Add(fCurrent)
+            .Add(fPreview)
+            .AddGlue()
+            .AddGroup(B_HORIZONTAL, 5)
+                .AddGlue()
+                .Add(fSetZone)
+            .End()
+        .End()
+        .SetInsets(5, 5, 5, 5);
 }
 
 

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
@@ -21 +21 @@
 
 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();
 
@@ -65 +66 @@
 
 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 +93 @@
             void                _CheckRange();
             bool                _IsValidDoubleDigit(int32 value);
             int32               _SectionValue(int32 index) const;
-
 private:
             BDate               fDate;
             bigtime_t           fLastKeyDownTime;

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;
 }
 
 
@@ -87 +51 @@
     DrawBorder(updateRect);
 
     for (uint32 idx = 0; idx < fSectionCount; idx++) {
-        DrawSection(idx, ((uint32)fFocus == idx) && IsFocus());
-        if (idx < fSectionCount -1)
-            DrawSeparator(idx);
+        DrawSection(idx, FrameForSection(idx),
+            ((uint32)fFocus == idx) && IsFocus());
+        if (idx < fSectionCount - 1)
+            DrawSeparator(idx, FrameForSeparator(idx));
     }
 }
 
@@ -103 +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;
             }
@@ -116 +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)
 {
@@ -141 +164 @@
         case B_LEFT_ARROW:
             fFocus -= 1;
             if (fFocus < 0)
-                fFocus = fSectionCount -1;
+                fFocus = fSectionCount - 1;
             SectionFocus(fFocus);
             break;
 
@@ -180 +203 @@
 uint32
 TSectionEdit::CountSections() const
 {
-    return fSectionList->CountItems();
+    return fSectionCount;
 }
 
 
@@ -191 +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;
 }
 
 
@@ -222 +244 @@
     BPoint left(fUpRect.left + 3, fUpRect.bottom - 1);
     BPoint right(left.x + 2 * (middle.x - left.x), fUpRect.bottom - 1);
 
-    SetPenSize(2);
+    SetPenSize(1);
+    SetLowColor(ViewColor());
 
     if (updateRect.Intersects(fUpRect)) {
         FillRect(fUpRect, B_SOLID_LOW);
@@ -244 +267 @@
 
     SetPenSize(1);
 }
-
-
-float
-TSectionEdit::SeparatorWidth() const
-{
-    return 0.0f;
-}
-

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);
 
-            BBitmap*            fBitmap;
-            OffscreenClock*     fClock;
+            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);
 
-            bool                fDrawSecondHand;
-            bool                fInteractive;
-            bool                fDraggingHourHand;
-            bool                fDraggingMinuteHand;
+            int32           fHours;
+            int32           fMinutes;
+            int32           fSeconds;
+            bool            fDirty;
+            
+            float           fCenterX;
+            float           fCenterY;
+            float           fRadius;
 
-            bool                fTimeChangeIsOngoing;
+            bool            fHourDragging;
+            bool            fMinuteDragging;
+            bool            fDrawSecondHand;
+            bool            fInteractive;
+
+            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 "NetworkTimeView.h"
 #include "TimeMessages.h"
 #include "TimeSettings.h"
 #include "ZoneView.h"
 
-
 #include <Application.h>
 #include <Catalog.h>
+#include <LayoutBuilder.h>
 #include <Message.h>
 #include <Screen.h>
 #include <TabView.h>
@@ -27 +28 @@
 #define B_TRANSLATE_CONTEXT "Time"
 
 TTimeWindow::TTimeWindow(BRect rect)
-    : BWindow(rect, B_TRANSLATE("Time"), B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE)
+    :
+    BWindow(rect, B_TRANSLATE("Time"), B_TITLED_WINDOW,
+        B_NOT_RESIZABLE | B_NOT_ZOOMABLE)
 {
     _InitWindow();
     _AlignWindow();
@@ -76 +79 @@
             SetRevertStatus();
             break;
 
+        case kMsgTryAllServers:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+
+        case kMsgSynchronizeAtBoot:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+
+        case kMsgEditServerList:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+            
+        case kMsgEditServerListWindowClosed:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+            
+        case kMsgResetServerList:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+            
+        case kMsgUpdateSettings:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+            
+        case kMsgSettingsUpdated:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+            
+        case kMsgDefaultServer:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+        
+        case kMsgSynchronize:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+            
+        case kMsgStopSynchronization:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+            
+        case kMsgStatusUpdate:
+            fNetworkTimeView->MessageReceived(message);
+            break;
+
         default:
             BWindow::MessageReceived(message);
             break;
@@ -102 +149 @@
 {
     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", "Revert",
-        new BMessage(kMsgRevert), B_FOLLOW_LEFT | B_FOLLOW_BOTTOM, B_WILL_DRAW);
-
-    fRevertButton->ResizeToPreferred();
+    fRevertButton = new BButton("revert", "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());
+    
+    BLayoutBuilder::Group<>(this, B_VERTICAL, 5)
+        .Add(fBaseView)
+        .AddGroup(B_HORIZONTAL, 5)
+            .Add(fRevertButton)
+            .AddGlue()
+        .End()
+        .SetInsets(5, 5, 5, 5);
 }
 
 

src/preferences/time/Jamfile

@@ -10 +10 @@
     BaseView.cpp
     Bitmaps.cpp
     DateTimeEdit.cpp
+    EditServerListWindow.cpp
     SectionEdit.cpp
     DateTimeView.cpp
+    NetworkTimeView.cpp
+    ntp.cpp
     Time.cpp
     TimeSettings.cpp
     TimeWindow.cpp
@@ -28 +31 @@
 
 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"
@@ -15 +16 @@
 #include "TimeMessages.h"
 #include "TimeWindow.h"
 
+#include <Box.h>
 #include <CalendarView.h>
+#include <Catalog.h>
 #include <CheckBox.h>
 #include <DateTime.h>
 #include <Entry.h>
@@ -32 +35 @@
 
 #include <syscalls.h>
 
+#undef B_TRANSLATE_CONTEXT
+#define B_TRANSLATE_CONTEXT "Time"
 
+
 using BPrivate::BCalendarView;
 using BPrivate::BDateTime;
 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),
@@ -204 +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", "Clock set to:");
-    AddChild(text);
-    text->ResizeToPreferred();
+    BStringView* text = new BStringView("clockSetTo",
+        B_TRANSLATE("Clock set to:"));
+    fLocalTime = new BRadioButton("localTime",
+        B_TRANSLATE("Local time"), new BMessage(kRTCUpdate));
+    fGmtTime = new BRadioButton("greenwichMeanTime",
+        B_TRANSLATE("GMT"), new BMessage(kRTCUpdate));
 
-    bounds.left += 10.0f;
-    bounds.top = text->Frame().bottom;
-    fLocalTime = new BRadioButton(bounds, "localTime", "Local time",
-        new BMessage(kRTCUpdate));
-    AddChild(fLocalTime);
-    fLocalTime->ResizeToPreferred();
-
-    bounds.left = fLocalTime->Frame().right + 10.0;
-    fGmtTime = new BRadioButton(bounds, "greenwichMeanTime", "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
@@ -18 +18 @@
 
 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;

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 <Alert.h>
 #include <Catalog.h>
 
 #include <unistd.h>
 
+#include "NetworkTimeView.h"
+#include "TimeWindow.h"
+
 #undef B_TRANSLATE_CONTEXT
 #define B_TRANSLATE_CONTEXT "Time"
 
@@ -24 +26 @@
 
 
 TimeApplication::TimeApplication()
-    : BApplication(kAppSignature),
-      fWindow(NULL)
+    : 
+    BApplication(kAppSignature),
+    fWindow(NULL)
 {
-    fWindow = new TTimeWindow(BRect(100, 100, 570, 327));
+    fWindow = new TTimeWindow(BRect(100, 100, 530, 360));
 }
 
 
@@ -47 +50 @@
 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();
 }
@@ -60 +64 @@
 int
 main(int argc, char** argv)
 {
-    TimeApplication app;
-    setuid(0);
-    app.Run();
+    if (argc > 1) {
+        if (!strcmp(argv[1], "--silent-update")) {
+            Settings settings;
+            bool boolean;
+            if (settings.Message().FindBool("synchronize at boot", &boolean)
+                == B_OK) {
+                    if (!boolean) return 0;
+                    update_time(settings.Message(), NULL);
+            }
+        }
+    }
+    else {
+        TimeApplication app;
+        setuid(0);
+        app.Run();
+    }
 
     return 0;
 }

src/preferences/time/EditServerListWindow.cpp

@@ +1 @@
+/*
+ * Copyright 2004, pinc Software. All Rights Reserved.
+ * Distributed under the terms of the MIT license.
+ */
+
+#include "EditServerListWindow.h"
+#include "NetworkTimeView.h"
+
+#include <Application.h>
+#include <TextView.h>
+#include <ScrollView.h>
+#include <Button.h>
+#include <Screen.h>
+
+#include <string.h>
+#include <stdlib.h>
+
+
+static const char *kServerDelimiters = ", \n\t";
+
+
+struct tokens {
+    char *buffer;
+    char *next;
+    const char *delimiters;
+};
+
+
+static void
+put_tokens(tokens &tokens)
+{
+    free(tokens.buffer);
+    tokens.buffer = NULL;
+}
+
+
+static status_t
+prepare_tokens(tokens &tokens, const char *text, const char *delimiters)
+{
+    tokens.buffer = strdup(text);
+    if (tokens.buffer == NULL)
+        return B_NO_MEMORY;
+
+    tokens.delimiters = delimiters;
+    tokens.next = tokens.buffer;
+    return B_OK;
+}
+
+
+static const char *
+next_token(tokens &tokens)
+{
+    char *token = strtok(tokens.next, tokens.delimiters);
+    if (tokens.next != NULL)
+        tokens.next = NULL;
+    if (token == NULL)
+        put_tokens(tokens);
+
+    return token;
+}
+
+
+//  #pragma mark -
+
+
+EditServerListWindow::EditServerListWindow(BRect position, const BMessage& settings, BLooper* looper)
+    : 
+    BWindow(position, "Edit Server List", B_TITLED_WINDOW,
+        B_ASYNCHRONOUS_CONTROLS),
+    fSettings(settings),
+    fLooper(looper)
+{
+    BRect rect = Bounds();
+    BView *view = new BView(rect, NULL, B_FOLLOW_ALL, B_WILL_DRAW);
+    view->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
+    AddChild(view);
+
+    rect = view->Bounds().InsetByCopy(5, 5);
+
+    BButton *button = new BButton(rect, "defaults", "Reset To Defaults",
+        new BMessage(kMsgResetServerList), B_FOLLOW_LEFT_RIGHT | B_FOLLOW_BOTTOM);
+    float width, height;
+    button->GetPreferredSize(&width, &height);
+    button->ResizeTo(rect.Width(), height);
+    button->MoveBy(0, rect.Height() - height);
+    button->SetTarget(be_app);
+    view->AddChild(button);
+
+    rect.bottom -= 5 + height;
+    rect.InsetBy(2, 2);
+    rect.right -= B_V_SCROLL_BAR_WIDTH;
+
+    fServerView = new BTextView(rect, "list",
+        rect.OffsetToCopy(B_ORIGIN).InsetByCopy(3, 3), B_FOLLOW_ALL);
+    fServerView->SetStylable(true);
+
+    BScrollView *scrollView = new BScrollView("scroller", fServerView, B_FOLLOW_ALL, B_WILL_DRAW, false, true);
+    view->AddChild(scrollView);
+
+    UpdateServerView(settings);
+
+    SetSizeLimits(200, 16384, 200, 16384);
+
+    if (Frame().LeftTop() == B_ORIGIN) {
+        // center on screen
+        BScreen screen;
+        MoveTo((screen.Frame().Width() - Bounds().Width()) / 2,
+            (screen.Frame().Height() - Bounds().Height()) / 2);
+    }
+}
+
+
+EditServerListWindow::~EditServerListWindow()
+{
+}
+
+
+void
+EditServerListWindow::UpdateDefaultServerView(const BMessage &message)
+{
+    int32 defaultServer;
+    if (message.FindInt32("default server", &defaultServer) != B_OK)
+        return;
+
+    BFont font(be_plain_font);
+    fServerView->SetFontAndColor(0, fServerView->TextLength(),
+        &font, B_FONT_FAMILY_AND_STYLE);
+
+    struct tokens tokens;
+    const char *server;
+    if (fSettings.FindString("server", defaultServer, &server) == B_OK
+        && prepare_tokens(tokens, fServerView->Text(), kServerDelimiters) == B_OK) {
+        const char *token;
+        while ((token = next_token(tokens)) != NULL) {
+            if (strcasecmp(token, server))
+                continue;
+
+            int32 start = int32(token - tokens.buffer);
+
+            BFont font;
+            font.SetFace(B_BOLD_FACE);
+            fServerView->SetFontAndColor(start, start + strlen(server),
+                &font, B_FONT_FAMILY_AND_STYLE);
+            
+            break;
+        }
+        put_tokens(tokens);
+    }
+}
+
+
+void
+EditServerListWindow::UpdateServerView(const BMessage &message)
+{
+    if (message.HasString("server") || message.HasBool("reset servers"))
+        fServerView->SetText("");
+
+    int32 defaultServer;
+    if (message.FindInt32("default server", &defaultServer) != B_OK)
+        defaultServer = 0;
+
+    const char *server;
+    int32 index = 0;
+    for (; message.FindString("server", index, &server) == B_OK; index++) {
+        int32 start, end;
+        fServerView->GetSelection(&start, &end);
+
+        fServerView->Insert(server);
+        fServerView->Insert("\n");
+    }
+
+    UpdateDefaultServerView(message);
+}
+
+
+void
+EditServerListWindow::UpdateServerList()
+{
+    // get old default server
+
+    int32 defaultServer;
+    if (fSettings.FindInt32("default server", &defaultServer) != B_OK)
+        defaultServer = 0;
+    const char *server;
+    if (fSettings.FindString("server", defaultServer, &server) != B_OK)
+        server = NULL;
+
+    // take over server list
+
+    struct tokens tokens;
+    if (prepare_tokens(tokens, fServerView->Text(), kServerDelimiters) == B_OK) {
+        BMessage servers(kMsgUpdateSettings);
+
+        int32 count = 0, newDefaultServer = -1;
+
+        const char *token;
+        while ((token = next_token(tokens)) != NULL) {
+            servers.AddString("server", token);
+            if (!strcasecmp(token, server))
+                newDefaultServer = count;
+
+            count++;
+        }
+
+        if (count != 0) {
+            if (newDefaultServer == -1)
+                newDefaultServer = 0;
+
+            servers.AddInt32("default server", newDefaultServer);
+            fLooper->PostMessage(&servers);
+        } else
+            fLooper->PostMessage(kMsgResetServerList);
+    }
+}
+
+
+bool
+EditServerListWindow::QuitRequested()
+{
+    fLooper->PostMessage(kMsgEditServerListWindowClosed);
+
+    BMessage update(kMsgUpdateSettings);
+    update.AddRect("edit servers frame", Frame());
+    fLooper->PostMessage(&update);
+
+    UpdateServerList();
+    return true;
+}
+
+
+void
+EditServerListWindow::MessageReceived(BMessage *message)
+{
+    switch (message->what) {
+        case kMsgServersEdited:
+            UpdateServerList();
+            break;
+
+        case kMsgSettingsUpdated:
+            if (message->HasString("server"))
+                UpdateServerView(*message);
+            else
+                UpdateDefaultServerView(*message);
+            break;
+    }
+}
+

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)
+    if (fFieldPositions == NULL || index * 2 + 1 >= (uint32)fFieldPosCount)
         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)
+    if (fFieldPositions == NULL || index * 2 + 2 >= (uint32)fFieldPosCount)
         return;
 
-    if (fFieldPositions == NULL || index * 2 + 2 > (uint32)fFieldPosCount)
-        return;
-
     BString field;
     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();
-    BLocale::Default()->FormatTime(&fText, fFieldPositions, fFieldPosCount,
-        time, B_MEDIUM_TIME_FORMAT);
+    
+    if (fFieldPositions != NULL) {
+        free(fFieldPositions);
+        fFieldPositions = NULL;
+    }
+    BLocale::Default()->FormatTime(&fText, fFieldPositions,
+        fFieldPosCount, time, B_MEDIUM_TIME_FORMAT);
+
+    if (fFields != NULL) {
+        free(fFields);
+        fFields = NULL;
+    }
     BLocale::Default()->GetTimeFields(fFields, fFieldCount,
         B_MEDIUM_TIME_FORMAT);
 }
@@ -405 +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),
@@ -476 +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)
+    if (fFieldPositions == NULL || index * 2 + 1 >= (uint32)fFieldPosCount)
         return;
 
-    if (fFieldPositions == NULL || index * 2 + 1 > (uint32)fFieldPosCount)
-        return;
-
     SetLowColor(ViewColor());
     if (hasFocus)
         SetLowColor(tint_color(ViewColor(), B_DARKEN_1_TINT));
@@ -503 +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)
+    if (fFieldPositions == NULL || index * 2 + 2 >= (uint32)fFieldPosCount)
         return;
 
-    if (fFieldPositions == NULL || index * 2 + 2 > (uint32)fFieldPosCount)
-        return;
-
     BString field;
     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;
 }
 
 
@@ -647 +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)
@@ -677 +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);
 }
@@ -797 +746 @@
 
     return value;
 }
+
+
+float
+TDateEdit::PreferredHeight()
+{
+    font_height fontHeight;
+    GetFontHeight(&fontHeight);
+    return ceilf((fontHeight.ascent + fontHeight.descent) * 1.4);
+}

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>
+#include <Message.h>
+#include <Path.h>
+
+#include "EditServerListWindow.h"
+#include "TimeMessages.h"
+
+class BMenuField;
+class BButton;
+class BCheckBox;
+class Monitor;
+class Settings;
+
+
+status_t
+update_time(const BMessage &settings, Monitor *monitor,
+    thread_id *_asyncThread);
+status_t
+update_time(const BMessage &settings, Monitor *monitor);
+
+
+class Settings {
+    public:
+        Settings();
+        ~Settings();
+
+        void CopyMessage(BMessage &message) const;
+        const BMessage &Message() const;
+        void UpdateFrom(BMessage &message);
+
+        void ResetServersToDefaults();
+        void ResetToDefaults();
+        status_t Load();
+        status_t Save();
+
+    private:
+        status_t GetPath(BPath &path);
+
+        BMessage    fMessage;
+        bool        fWasUpdated;
+};
+
+
+class NetworkTimeView : public BGroupView {
+    public:
+        NetworkTimeView(const char* name);
+        
+        virtual void MessageReceived(BMessage* message);
+    private:
+        void _InitView();
+        void _UpdateServerListMenu();
+    private:
+    
+        BMenuField*     fServerListMenuField;
+        BButton*        fEditServerListButton;
+        BButton*        fSynchronizeButton;
+        BCheckBox*      fTryAllServersCheckBox;
+        BCheckBox*      fSynchronizeAtBootCheckBox;
+
+        BWindow*        fEditServerListWindow;
+        
+        thread_id       fUpdateThread;
+        const char*     fStatusString;
+        Settings        fSettings;
+};
+    
+#endif

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();

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();

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();
-
-            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);
-
-            void            SetHourHand(BPoint point);
-            void            SetMinuteHand(BPoint point);
-
-            void            SetHourDragging(bool dragging);
-            void            SetMinuteDragging(bool dragging);
-
-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;
-
-            float           fCenterX;
-            float           fCenterY;
-            float           fRadius;
-
-            bool            fHourDragging;
-            bool            fMinuteDragging;
-            
-            bool            fDrawSecondHand;
-};
-
-
-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)
-{
-    SetFlags(Flags() | B_SUBPIXEL_PRECISE);
-
-    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)
-
-    fRadius = floorf((MIN(bounds.Width(), bounds.Height()) / 2.0)) - 2.5;
-    fRadius -= 3;
-}
-
-
-OffscreenClock::~OffscreenClock()
-{
-}
-
-
 void
-OffscreenClock::SetTime(int32 hour, int32 minute, int32 second)
+TAnalogClock::GetTime(int32* hour, int32* minute, int32* second)
 {
-    if (fHours == hour && fMinutes == minute && fSeconds == second)
-        return;
-
-    fHours = hour;
-    fMinutes = minute;
-    fSeconds = second;
-
-    fDirty = true;
-}
-
-
-void
-OffscreenClock::GetTime(int32* hour, int32* minute, int32* second)
-{
     *hour = fHours;
     *minute = fMinutes;
     *second = fSeconds;
@@ -122 +35 @@
 
 
 void
-OffscreenClock::DrawClock()
+TAnalogClock::DrawClock()
 {
     if (!LockLooper())
         return;
@@ -132 +45 @@
     rgb_color background = ui_color(B_PANEL_BACKGROUND_COLOR);
     SetHighColor(background);
     FillRect(bounds);
-
-
+    
     bounds.Set(fCenterX - fRadius, fCenterY - fRadius,
         fCenterX + fRadius, fCenterY + fRadius);
 
@@ -207 +119 @@
 }
 
 
+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 +171 @@
 
 
 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 +196 @@
 
 
 void
-OffscreenClock::SetMinuteHand(BPoint point)
+TAnalogClock::SetMinuteHand(BPoint point)
 {
     point.x -= fCenterX;
     point.y -= fCenterY;
@@ -260 +209 @@
 }
 
 
-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 +235 @@
 
 
 bool
-OffscreenClock::_InHand(BPoint point, int32 ticks, float radius)
+TAnalogClock::_InHand(BPoint point, int32 ticks, float radius)
 {
     point.x -= fCenterX;
     point.y -= fCenterY;
@@ -323 +256 @@
 
 
 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;
@@ -366 +297 @@
 //  #pragma mark -
 
 
-TAnalogClock::TAnalogClock(BRect frame, const char* name,
+TAnalogClock::TAnalogClock(const char* name,
     bool drawSecondHand, bool interactive)
     :
-    BView(frame, name, B_FOLLOW_NONE, B_WILL_DRAW | B_DRAW_ON_CHILDREN),
-    fBitmap(NULL),
-    fClock(NULL),
+    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),
-    fDraggingHourHand(false),
-    fDraggingMinuteHand(false),
     fTimeChangeIsOngoing(false)
 {
-    _InitView(frame);
+    SetFlags(Flags() | B_SUBPIXEL_PRECISE);
 }
 
 
 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;
@@ -445 +359 @@
         return;
     }
     
-    fDraggingMinuteHand = fClock->InMinuteHand(point);
-    if (fDraggingMinuteHand) {
-        fClock->SetMinuteDragging(true);
+    if (InMinuteHand(point)) {
+        fMinuteDragging = true;
+        fDirty = true;
         SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
         Invalidate();
         return;
     }
-    fDraggingHourHand = fClock->InHourHand(point);
-    if (fDraggingHourHand) {
-        fClock->SetHourDragging(true);
+    if (InHourHand(point)) {
+        fHourDragging = true;
+        fDirty = true;
         SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
         Invalidate();
         return;
@@ -470 +384 @@
         return;
     }
     
-    if (fDraggingHourHand || fDraggingMinuteHand) {
+    if (fHourDragging || fMinuteDragging) {
         int32 hour, minute, second;
-        fClock->GetTime(&hour, &minute, &second);
+        GetTime(&hour, &minute, &second);
         BMessage message(H_USER_CHANGE);
         message.AddBool("time", true);
         message.AddInt32("hour", hour);
@@ -480 +394 @@
         Window()->PostMessage(&message);
         fTimeChangeIsOngoing = true;
     }
-    fDraggingHourHand = false;
-    fDraggingMinuteHand = false;
-    fClock->SetMinuteDragging(false);
-    fClock->SetHourDragging(false);
+    fHourDragging = false;
+    fDirty = true;
+    fMinuteDragging = false;
+    fDirty = true;
 }
 
 
@@ -495 +409 @@
         return;
     }
 
-    if (fDraggingMinuteHand)
-        fClock->SetMinuteHand(point);
-    if (fDraggingHourHand)
-        fClock->SetHourHand(point);
+    if (fMinuteDragging)
+        SetMinuteHand(point);
+    if (fHourDragging)
+        SetHourHand(point);
 
     Invalidate();
 }
@@ -507 +421 @@
 void
 TAnalogClock::Draw(BRect /*updateRect*/)
 {
-    if (fBitmap) {
-        if (fClock->IsDirty())
-            fClock->DrawClock();
-        DrawBitmap(fBitmap, BPoint(0, 0));
-    }
+    if (fDirty)
+        DrawClock();
 }
 
 
@@ -519 +430 @@
 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)
+    if (fHourDragging || fMinuteDragging || fTimeChangeIsOngoing)
         return;
+    
+    if (fHours == hour && fMinutes == minute && fSeconds == second)
+        return;
 
-    if (fClock)
-        fClock->SetTime(hour, minute, second);
+    fHours = hour;
+    fMinutes = minute;
+    fSeconds = second;
 
+    fDirty = true;
+
     BWindow* window = Window();
     if (window && window->Lock()) {
         Invalidate();
@@ -533 +450 @@
 }
 
 
+bool
+TAnalogClock::IsChangingTime()
+{
+    return fTimeChangeIsOngoing;
+}
+
+
 void
 TAnalogClock::ChangeTimeFinished()
 {

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 {
-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;
-
+protected:          
             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 {
@@ -26 +28 @@
 }
 
 
-TTZDisplay::TTZDisplay(BRect frame, const char* name, const char* label)
-    : BView(frame, name, B_FOLLOW_NONE, B_WILL_DRAW),
+TTZDisplay::TTZDisplay(const char* name, const char* label)
+    : BView(name, B_WILL_DRAW),
       fLabel(label),
       fText(""),
       fTime("")
@@ -121 +123 @@
     Invalidate();
 }
 
+
+BSize
+TTZDisplay::MaxSize()
+{
+    BSize size = _CalcPrefSize();
+    size.width = B_SIZE_UNLIMITED;
+    
+    return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
+        size);
+}
+
+
+BSize
+TTZDisplay::MinSize()
+{
+    return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
+        _CalcPrefSize());
+}
+
+
+BSize
+TTZDisplay::PreferredSize()
+{
+    return MinSize();
+}
+
+
+BSize
+TTZDisplay::_CalcPrefSize()
+{
+    font_height fontHeight;
+    GetFontHeight(&fontHeight);
+    
+    BSize size;
+    size.height = 2 * ceilf(fontHeight.ascent + fontHeight.descent);
+    size.width =StringWidth(
+        "                                                       ");
+    return size;    
+}
+

src/preferences/time/TimeMessages.h

@@ -46 +46 @@
 // change time finished
 const uint32 kChangeTimeFinished = 'tcfi';
 
+// network time messages
+const uint32 kMsgNetworkTimeSettings = 'ntst';
+const uint32 kMsgDefaultServer = 'dfsr';
+const uint32 kMsgEditServerList = 'esrv';
+const uint32 kMsgTryAllServers = 'tras';
+const uint32 kMsgSynchronizeAtBoot = 'synb';
+const uint32 kMsgSynchronize = 'sync';
+const uint32 kMsgStopSynchronization = 'stps';
+const uint32 kMsgStatusUpdate = 'stup';
 
+// network time edit window messages
+const uint32 kMsgUpdateSettings = 'upse';
+const uint32 kMsgSettingsUpdated = 'seUp';
+const uint32 kMsgServersEdited = 'sedt';
+const uint32 kMsgResetServerList = 'rtsl';
+const uint32 kMsgEditServerListWindowClosed = 'eswc';
+
+
 #endif  // _TIME_MESSAGES_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 {
@@ -39 +39 @@
             TTimeBaseView*      fBaseView;
             DateTimeView*       fDateTimeView;
             TimeZoneView*       fTimeZoneView;
+            NetworkTimeView*    fNetworkTimeView;
             BButton*            fRevertButton;
 };
 

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();

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;