Merge lp:~charlesk/indicator-datetime/cpp into lp:indicator-datetime/14.04

[Charles Kerr]

Merge a refactor of indicator-datetime designed around making its components testable in isolation and in groups.

This is the long promised super-testable indicator-datetime refactor.

Basic overview of the code:

  The app's model is represented by the "State" class, and "Menu" objects
  are the corresponding views. "State" is a simple container for various
  properties, and menus connect to those properties' changed() signals to
  know when the view needs to be refreshed.

  As main.c shows, the app's very simple flow is to instantiate a state,
  buiid menus as Views to the state, and export the menus on DBus.

  State is a simple aggregate of its components (such as a "Clock"
  or "Planner" object to get the current time and upcoming appointments,
  respectively), so you can plug in different components for production
  and testing. By mixing-and-matching components as needed, you can
  test specific components in isolation, test how more than one
  components interact, or plug in all-live components for production.

  Once you have the state, the rest is straightforward: use MenuFactory
  to create Menu objects for each profile, then export them to DBus
  using the Exporter class.

  See also the README for suggestions on which actual files to read
  first when you're getting started with this codebase.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:347
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/151/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/31/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/31/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/151/rebuild

review: Needs Fixing (continuous-integration)

[lp:~charlesk/indicator-datetime/cpp]

348. By Charles Kerr on 2014-01-28

add libdbustest1-dev to debian/control's Build-Depends to pick up dbus-test-runner's dbusmock interface for the geoclue unit tests.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:348
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/152/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/32/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/32/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/152/rebuild

review: Needs Fixing (continuous-integration)

[lp:~charlesk/indicator-datetime/cpp]

349. By Charles Kerr on 2014-01-28

update POTFILES.in

350. By Charles Kerr on 2014-01-28

silence compiler warning

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:350
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/153/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/33/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/33/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/153/rebuild

review: Needs Fixing (continuous-integration)

[lp:~charlesk/indicator-datetime/cpp]

351. By Charles Kerr on 2014-01-28

make utils.cpp's generate_full_format_string_at_time() a standalone function so that the panels can use the utils functions without a libindicatordatetime dependency

352. By Charles Kerr on 2014-01-28

cleanup from previous commit: since Formatter code was migrated to utils.c so that it could be used standalone by the panels, there's now code duplication between Utils and Formatter. Remove code duplication s.t. Formatter uses the Utils code as well.

353. By Charles Kerr on 2014-01-28

fix bootstrap error in unit tests by ensuring we always use the local gschema instead of the one preinstalled on the system

354. By Charles Kerr on 2014-01-29

fix free-memory-read bug found by valgrind testing

355. By Charles Kerr on 2014-01-29

fix Task leak found by valgrind testing

356. By Charles Kerr on 2014-01-29

fix GDateTime leak found by valgrind testing

357. By Charles Kerr on 2014-01-29

fix g_date_time_format() leak found by valgrind testing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:353
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/154/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/34/console
    None: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/34/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/154/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:350
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/155/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/35/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/35/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/155/rebuild

review: Needs Fixing (continuous-integration)

[lp:~charlesk/indicator-datetime/cpp]

358. By Charles Kerr on 2014-01-29

ensure the unit tests' default locale supports utf-8

359. By Charles Kerr on 2014-01-29

add dbus-test-runner and python3-dbusmock to Build-Depends; they're needed by the unit tests.

360. By Charles Kerr on 2014-01-29

comment out unit tests that require a version of dbus-test-runner that hasn't landed yet.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:357
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/156/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/36/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/36/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/156/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:350
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/157/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/37
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/37
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/37/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/157/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:360
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/158/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/38
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/38
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/38/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/158/rebuild

review: Approve (continuous-integration)

[Sebastien Bacher (seb128)]

I've built/tested that a bit on my trusty desktop, it seems to work mostly fine (even fixing some bugs on the way like the tz change not being picked up or the week number setting not applying until restart), good work!

Small user comments:
- the "add an event" item is not enabled while I've evolution installed (that used to work)
- toggle the preference to show or not the calendar widget doesn't work dynamically

[lp:~charlesk/indicator-datetime/cpp]

361. By Charles Kerr on 2014-01-29

sync with lp:~larsu/indicator-datetime/reset-date and add corresponding unit tests.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:361
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/161/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/41
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/41
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/41/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/161/rebuild

review: Approve (continuous-integration)

[lp:~charlesk/indicator-datetime/cpp]

362. By Charles Kerr on 2014-01-29

sync with lp:~seb128/indicator-datetime/use-correct-gtkbuilder-location

363. By Charles Kerr on 2014-01-29

fix instant calendar toggle issue reported in testing by seb128; add a test for this regression

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:362
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/162/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/42
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/42
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/42/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/162/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:363
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/163/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/43/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/43/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/163/rebuild

review: Needs Fixing (continuous-integration)

[lp:~charlesk/indicator-datetime/cpp]

364. By Charles Kerr on 2014-01-29

fix disabled 'Add Event…' menuitem issue reported in testing by seb128; add a test for this regression

365. By Charles Kerr on 2014-01-29

sync with trunk

366. By Charles Kerr on 2014-01-29

remove unused old file

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:364
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/164/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/44
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/44
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/44/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/164/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:366
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/165/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/45
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/45
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/45/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/165/rebuild

review: Approve (continuous-integration)

[Sebastien Bacher (seb128)]

testing the current version on the phone, I noticed those changes/issues:

- the indicator menu is "current date/add an event/configure" (where the "add an event" does nothing), it used to be "current date/clock app/configure"

- when changing the timezone, in the system settings, the hour doesn't change in the indicator (not even at the next minute) (/etc/timezone is correctly updated and the system settings panel has the right time after changing)

[Thomas Strehl (strehl-t)]

the second issue is not a new regression, see https://bugs.launchpad.net/indicator-datetime/+bug/1267111

[Sebastien Bacher (seb128)]

@Thomas: right, in fact the issue has been fixed in the 3.10/pre-refactoring codebase, it needs to be fixed there as well, see Charle's comment on https://bugs.launchpad.net/ubuntu/+source/indicator-datetime/+bug/1271484/comments/3

[Sebastien Bacher (seb128)]

(well, to be exact, Charles' comment stated that the issue was fixed in the refactoring, which seems to not be true)

[Charles Kerr (charlesk)]

> the indicator menu is "current date/add an event/configure" (where the "add an event" does nothing), it used to be "current date/clock app/configure"

Confirmed, will fix ASAP.

> when changing the timezone, in the system settings, the hour doesn't change in the indicator

I'm not able to reproduce this using this MP, will follow up with seb128 in irc.

[lp:~charlesk/indicator-datetime/cpp]

367. By Charles Kerr on 2014-01-30

fix 'clock app' menuitem on phone profile reported by seb128 and update the corresponding unit tests

368. By Charles Kerr on 2014-01-30

as per review, don't inline getters

369. By Charles Kerr on 2014-01-30

as per review, don't inline unless there are performance issues

370. By Charles Kerr on 2014-01-30

as per review, make explicit the dependency injection that was implicit in main()

371. By Charles Kerr on 2014-01-30

as per review, constify getters where possible. This isn't always possible due to system APIs asking for non-const pointers.

372. By Charles Kerr on 2014-01-30

as per review, there were a few places that accidentally passed a shared_ptr<X>& instead of a const shared_ptr<X>&

373. By Charles Kerr on 2014-01-30

following on the review comment covered in the last commit, use shared_ptr<const X> instead of shared_ptr<X> where possible.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:373
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/169/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/49
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/49
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/49/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/169/rebuild

review: Approve (continuous-integration)

[Charles Kerr (charlesk)]

seb128, there seems to be a separate issue with monitoring /etc/timezone on the phone that's contributing to the timezone issue you're seeing, and I don't think it's specific to indicator-dateteime so let's handle it separately from this MP.

I've written up what I found this afternoon at https://bugs.launchpad.net/ubuntu/+source/indicator-datetime/+bug/1271484/comments/4 instead of in this MP.

[lp:~charlesk/indicator-datetime/cpp]

374. By Charles Kerr on 2014-01-30

remove dead files

375. By Charles Kerr on 2014-01-31

copyediting: as per review, use name_of_thing() instead of get_name_of_thing() or getNameOfThing()

376. By Charles Kerr on 2014-01-31

copyediting: remove dead '#if 0''ed code

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:376
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/171/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-amd64-ci/51
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/51
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-trusty-armhf-ci/51/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/171/rebuild

review: Approve (continuous-integration)

[Sebastien Bacher (seb128)]

@Thomas: "Finally land this. Other, still open bugs will be fixed in subsequent commits." doesn't seem like a nice commit message, can we rather have one that describe what the changes are about?

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-01-10 01:45:41 +0000
+++ CMakeLists.txt	2014-01-31 00:43:10 +0000
@@ -40,8 +40,9 @@
                    libedataserver-1.2>=3.5
                    libnotify>=0.7.6
                    url-dispatcher-1>=1
+                   properties-cpp>=0.0.1
                    json-glib-1.0>=0.16.2)
-include_directories (${SERVICE_INCLUDE_DIRS})
+include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
 
 pkg_check_modules (PANEL_DEPS
                    glib-2.0>=2.36
@@ -86,12 +87,14 @@
 ##
 
 set (CC_WARNING_ARGS " -Wall -Wshadow -Wextra -Wunused -Wformat=2 -Wno-missing-field-initializers")
+set (CXX_WARNING_ARGS " -Wall -Wextra -pedantic -Wno-missing-field-initializers")
 
-include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src)
-include_directories (${CMAKE_CURRENT_BINARY_DIR}/src)
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/include)
+include_directories (${CMAKE_CURRENT_BINARY_DIR}/include)
 
 # testing & coverage
 if (${enable_tests})
+  pkg_check_modules (DBUSTEST REQUIRED dbustest-1>=14.04.0)
   set (GTEST_SOURCE_DIR /usr/src/gtest/src)
   set (GTEST_INCLUDE_DIR ${GTEST_SOURCE_DIR}/..)
   set (GTEST_LIBS -lpthread)
@@ -102,16 +105,17 @@
 endif ()
 
 # actually build things
-add_subdirectory (src)
+add_subdirectory(include)
+add_subdirectory(src)
 if (BUILD_PANEL)
   add_subdirectory (panel-gnome)
 endif ()
 if (BUILD_UNITY_PANEL)
   add_subdirectory (panel-unity)
 endif ()
-add_subdirectory (data)
-add_subdirectory (po)
+add_subdirectory(data)
+add_subdirectory(po)
 if (${enable_tests})
-  add_subdirectory (tests)
+  add_subdirectory(tests)
 endif ()
 

=== modified file 'README'
--- README	2013-10-09 16:39:36 +0000
+++ README	2014-01-31 00:43:10 +0000
@@ -68,3 +68,56 @@
    - x-canonical-time-format  s strftime format string
 
 
+
+CODE
+====
+
+Model
+
+  The app's model is represented by the "State" class, and "Menu" objects
+  are the corresponding views. "State" is a simple container for various
+  properties, and menus connect to those properties' changed() signals to
+  know when the view needs to be refreshed.
+
+  As one can see in main.c, the app's very simple flow is to instantiate
+  a state and its properties, build menus that correspond to the state,
+  and export the menus on DBus.
+
+  Because State is a simple aggregate of its components (such as a "Clock"
+  or "Planner" object to get the current time and upcoming appointments,
+  respectively), one can plug in live components for production and mock
+  components for unit tests. The entire backend can be mix-and-matched by
+  adding the desired test-or-production components.
+
+  Start with:
+  include/datetime/state.h
+  include/datetime/clock.h
+  include/datetime/locations.h
+  include/datetime/planner.h
+  include/datetime/settings.h
+  include/datetime/timezones.h
+
+  Implementations:
+  include/datetime/settings-live.h
+  include/datetime/locations-settings.h
+  include/datetime/planner-eds.h
+  include/datetime/timezones-live.h
+
+View
+
+  Menu is a mostly-opaque class to wrap GMenu code. Its subclasses contain
+  the per-profile logic of which sections/menuitems to show and which to hide.
+  Menus are instantiated via the MenuFactory, which takes a state and profile.
+
+  Actions is a mostly-opaque class to wrap our GActionGroup. Its subclasses
+  contain the code that actually executed when an action is triggered (ie,
+  LiveActions for production and MockActions for testing).
+
+  Exporter exports the Actions and Menus onto the DBus, and also emits a
+  signal if/when the busname is lost so indicator-datetime-service knows
+  when to exit.
+
+  include/datetime/menu.h
+  include/datetime/actions.h
+  include/datetime/exporter.h
+  

=== modified file 'cmake/GCov.cmake'
--- cmake/GCov.cmake	2013-10-18 19:22:54 +0000
+++ cmake/GCov.cmake	2014-01-31 00:43:10 +0000
@@ -29,7 +29,8 @@
         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
         COMMAND "${CMAKE_CTEST_COMMAND}" --force-new-ctest-process --verbose
         COMMAND "${LCOV_EXECUTABLE}" --directory ${CMAKE_BINARY_DIR} --capture | ${CMAKE_SOURCE_DIR}/trim-lcov.py > dconf-lcov.info
-        COMMAND LANG=C "${GENHTML_EXECUTABLE}" --prefix ${CMAKE_BINARY_DIR} --output-directory lcov-html --legend --show-details dconf-lcov.info
+        COMMAND "${LCOV_EXECUTABLE}" -r dconf-lcov.info /usr/include/\\*  -o nosys-lcov.info
+        COMMAND LANG=C "${GENHTML_EXECUTABLE}" --prefix ${CMAKE_BINARY_DIR} --output-directory lcov-html --legend --show-details nosys-lcov.info
         COMMAND ${CMAKE_COMMAND} -E echo ""
         COMMAND ${CMAKE_COMMAND} -E echo "file://${CMAKE_BINARY_DIR}/lcov-html/index.html"
         COMMAND ${CMAKE_COMMAND} -E echo "")

=== modified file 'debian/control'
--- debian/control	2014-01-14 04:41:03 +0000
+++ debian/control	2014-01-31 00:43:10 +0000
@@ -5,6 +5,8 @@
 # language-pack-en-base is for the unit tests s.t. we can test in 12h and 24h locales
 Build-Depends: cmake,
                dbus,
+               dbus-test-runner,
+               python3-dbusmock,
                debhelper (>= 9), 
                dh-translations,
                intltool (>= 0.35.0), 
@@ -28,6 +30,8 @@
                libunity-control-center-dev,
                libtimezonemap1-dev,
                liburl-dispatcher1-dev,
+               libproperties-cpp-dev,
+               libdbustest1-dev,
                locales,
 Standards-Version: 3.9.3
 Homepage: https://launchpad.net/indicator-datetime

=== added directory 'include'
=== added file 'include/CMakeLists.txt'
--- include/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/CMakeLists.txt	2014-01-31 00:43:10 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(datetime)

=== added directory 'include/datetime'
=== added file 'include/datetime/CMakeLists.txt'
--- include/datetime/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/datetime/CMakeLists.txt	2014-01-31 00:43:10 +0000
@@ -0,0 +1,2 @@
+
+

=== added file 'include/datetime/actions-live.h'
--- include/datetime/actions-live.h	1970-01-01 00:00:00 +0000
+++ include/datetime/actions-live.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_ACTIONS_LIVE_H
+#define INDICATOR_DATETIME_ACTIONS_LIVE_H
+
+#include <datetime/actions.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Production implementation of the Actions interface.
+ *
+ * Delegates URLs, sets the timezone via org.freedesktop.timedate1, etc.
+ *
+ * @see MockActions
+ */
+class LiveActions: public Actions
+{
+public:
+    LiveActions(const std::shared_ptr<State>& state_in);
+    ~LiveActions() =default;
+
+    void open_desktop_settings();
+    void open_phone_settings();
+    void open_phone_clock_app();
+    void open_planner();
+    void open_planner_at(const DateTime&);
+    void open_appointment(const std::string& uid);
+    void set_location(const std::string& zone, const std::string& name);
+    void set_calendar_date(const DateTime&);
+
+protected:
+    virtual void execute_command(const std::string& command);
+    virtual void dispatch_url(const std::string& url);
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_ACTIONS_H

=== added file 'include/datetime/actions.h'
--- include/datetime/actions.h	1970-01-01 00:00:00 +0000
+++ include/datetime/actions.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_ACTIONS_H
+#define INDICATOR_DATETIME_ACTIONS_H
+
+#include <datetime/date-time.h>
+#include <datetime/state.h>
+
+#include <memory> // shared_ptr
+#include <string>
+
+#include <gio/gio.h> // GSimpleActionGroup
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Interface for all the actions that can be activated by users.
+ *
+ * This is a simple C++ wrapper around our GActionGroup that gets exported
+ * onto the bus. Subclasses implement the actual code that should be run
+ * when a particular action is triggered.
+ */
+class Actions
+{
+public:
+    virtual void open_desktop_settings() =0;
+    virtual void open_phone_settings() =0;
+    virtual void open_phone_clock_app() =0;
+    virtual void open_planner() =0;
+    virtual void open_planner_at(const DateTime&) =0;
+    virtual void open_appointment(const std::string& uid) =0;
+    virtual void set_location(const std::string& zone, const std::string& name)=0;
+    void set_calendar_date(const DateTime&);
+    GActionGroup* action_group();
+    const std::shared_ptr<State> state() const;
+
+protected:
+    Actions(const std::shared_ptr<State>& state);
+    virtual ~Actions();
+
+private:
+    std::shared_ptr<State> m_state;
+    GSimpleActionGroup* m_actions = nullptr;
+    void update_calendar_state();
+
+    // we've got raw pointers in here, so disable copying
+    Actions(const Actions&) =delete;
+    Actions& operator=(const Actions&) =delete;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_ACTIONS_H

=== added file 'include/datetime/appointment.h'
--- include/datetime/appointment.h	1970-01-01 00:00:00 +0000
+++ include/datetime/appointment.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_APPOINTMENT_H
+#define INDICATOR_DATETIME_APPOINTMENT_H
+
+#include <datetime/date-time.h>
+#include <string>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Plain Old Data Structure that represents a calendar appointment.
+ *
+ * @see Planner
+ */
+struct Appointment
+{
+public:
+    std::string color; 
+    std::string summary;
+    std::string url;
+    std::string uid;
+    bool is_event = false;
+    bool is_daily = false;
+    bool has_alarms = false;
+    DateTime begin;
+    DateTime end;
+
+    bool operator== (const Appointment& that) const;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_APPOINTMENT_H

=== added file 'include/datetime/clock-mock.h'
--- include/datetime/clock-mock.h	1970-01-01 00:00:00 +0000
+++ include/datetime/clock-mock.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_CLOCK_MOCK_H
+#define INDICATOR_DATETIME_CLOCK_MOCK_H
+
+#include <datetime/clock.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+/**
+ * \brief A clock that uses a client-provided time instead of the system time.
+ */
+class MockClock: public Clock
+{
+public:
+    MockClock(const DateTime& dt): m_localtime(dt) {}
+    ~MockClock() =default;
+
+    DateTime localtime() const { return m_localtime; }
+
+    void set_localtime(const DateTime& dt) {
+        const auto old = m_localtime;
+        m_localtime = dt;
+        if (!DateTime::is_same_minute(old, m_localtime))
+            minute_changed();
+        if (!DateTime::is_same_day(old, m_localtime))
+            date_changed();
+    }
+
+private:
+    DateTime m_localtime;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_CLOCK_MOCK_H

=== added file 'include/datetime/clock.h'
--- include/datetime/clock.h	1970-01-01 00:00:00 +0000
+++ include/datetime/clock.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_CLOCK_H
+#define INDICATOR_DATETIME_CLOCK_H
+
+#include <datetime/date-time.h>
+
+#include <core/property.h>
+#include <core/signal.h>
+
+#include <gio/gio.h> // GDBusConnection
+
+#include <memory> // std::shared_ptr, std::unique_ptr
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief A clock.
+ */
+class Clock
+{
+public:
+    virtual ~Clock();
+    virtual DateTime localtime() const =0;
+
+    /** \brief A signal which fires when the clock's minute changes */
+    core::Signal<> minute_changed;
+
+    /** \brief A signal which fires when the clock's date changes */
+    core::Signal<> date_changed;
+
+protected:
+    Clock();
+
+    /** \brief Compares old and new times, emits minute_changed() or date_changed() signals if appropriate */
+    void maybe_emit (const DateTime& a, const DateTime& b);
+
+private:
+    static void on_system_bus_ready(GObject*, GAsyncResult*, gpointer);
+    static void on_prepare_for_sleep(GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant*, gpointer);
+
+    GCancellable * m_cancellable = nullptr;
+    GDBusConnection * m_system_bus = nullptr;
+    unsigned int m_sleep_subscription_id = 0;
+
+    // we've got raw pointers and GSignal tags in here, so disable copying
+    Clock(const Clock&) =delete;
+    Clock& operator=(const Clock&) =delete;
+};
+
+/***
+****
+***/
+
+class Timezones;
+
+/**
+ * \brief A live #Clock that provides the actual system time.
+ */
+class LiveClock: public Clock
+{
+public:
+    LiveClock (const std::shared_ptr<const Timezones>& zones);
+    virtual ~LiveClock();
+    virtual DateTime localtime() const;
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> p;
+};
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_CLOCK_H

=== added file 'include/datetime/date-time.h'
--- include/datetime/date-time.h	1970-01-01 00:00:00 +0000
+++ include/datetime/date-time.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_DATETIME_H
+#define INDICATOR_DATETIME_DATETIME_H
+
+#include <glib.h> // GDateTime
+
+#include <ctime> // time_t
+#include <memory> // std::shared_ptr
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief A simple C++ wrapper for GDateTime to simplify ownership/refcounts
+ */
+class DateTime
+{
+public:
+    static DateTime NowLocal();
+    explicit DateTime(time_t t);
+    explicit DateTime(GDateTime* in=nullptr);
+    DateTime& operator=(GDateTime* in);
+    DateTime& operator=(const DateTime& in);
+    DateTime to_timezone(const std::string& zone) const;
+    void reset(GDateTime* in=nullptr);
+
+    GDateTime* get() const;
+    GDateTime* operator()() const {return get();}
+
+    std::string format(const std::string& fmt) const;
+    int day_of_month() const;
+    int64_t to_unix() const;
+
+    bool operator<(const DateTime& that) const;
+    bool operator!=(const DateTime& that) const;
+    bool operator==(const DateTime& that) const;
+
+    static bool is_same_day(const DateTime& a, const DateTime& b);
+    static bool is_same_minute(const DateTime& a, const DateTime& b);
+
+private:
+    std::shared_ptr<GDateTime> m_dt;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_DATETIME_H

=== added file 'include/datetime/dbus-shared.h'
--- include/datetime/dbus-shared.h	1970-01-01 00:00:00 +0000
+++ include/datetime/dbus-shared.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ *   Charles Kerr <[e-mail]>
+ */
+
+
+#define BUS_NAME "com.canonical.indicator.datetime"
+
+#define BUS_PATH "/com/canonical/indicator/datetime"
+

=== added file 'include/datetime/exporter.h'
--- include/datetime/exporter.h	1970-01-01 00:00:00 +0000
+++ include/datetime/exporter.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_EXPORTER_H
+#define INDICATOR_DATETIME_EXPORTER_H
+
+#include <datetime/actions.h>
+#include <datetime/menu.h>
+
+#include <core/signal.h>
+
+#include <gio/gio.h> // GActionGroup
+
+#include <memory> // std::shared_ptr
+#include <vector>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Exports actions and menus to DBus. 
+ */
+class Exporter
+{
+public:
+    Exporter() =default;
+    ~Exporter();
+
+    core::Signal<> name_lost;
+
+    void publish(const std::shared_ptr<Actions>& actions,
+                 const std::vector<std::shared_ptr<Menu>>& menus);
+
+private:
+    static void on_bus_acquired(GDBusConnection*, const gchar *name, gpointer gthis);
+    void on_bus_acquired(GDBusConnection*, const gchar *name);
+
+    static void on_name_lost(GDBusConnection*, const gchar *name, gpointer gthis);
+    void on_name_lost(GDBusConnection*, const gchar *name);
+
+    std::set<guint> m_exported_menu_ids;
+    guint m_own_id = 0;
+    guint m_exported_actions_id = 0;
+    GDBusConnection * m_dbus_connection = nullptr;
+    std::shared_ptr<Actions> m_actions;
+    std::vector<std::shared_ptr<Menu>> m_menus;
+
+    // we've got raw pointers and gsignal tags in here, so disable copying
+    Exporter(const Exporter&) =delete;
+    Exporter& operator=(const Exporter&) =delete;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_EXPORTER_H

=== added file 'include/datetime/formatter.h'
--- include/datetime/formatter.h	1970-01-01 00:00:00 +0000
+++ include/datetime/formatter.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_FORMATTER_H
+#define INDICATOR_DATETIME_FORMATTER_H
+
+#include <core/property.h>
+#include <core/signal.h>
+
+#include <datetime/clock.h>
+#include <datetime/settings.h>
+#include <datetime/utils.h> // is_locale_12h()
+
+#include <glib.h>
+
+#include <string>
+#include <memory>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+class Clock;
+class DateTime;
+
+/***
+****
+***/
+
+/**
+ * \brief Provide the strftime() format strings
+ *
+ * This is a simple goal, but getting there has a lot of options and edge cases:
+ *
+ *  - The default time format can change based on the locale.
+ *
+ *  - The user's settings can change or completely override the format string.
+ *
+ *  - The time formats are different on the Phone and Desktop profiles.
+ *
+ *  - The time format string in the Locations' menuitems uses (mostly)
+ *    the same time format as the header, except for some changes.
+ *
+ *  - The 'current time' format string in the Locations' menuitems also
+ *    prepends the string 'Yesterday' or 'Today' if it differs from the
+ *    local time, so Formatter needs to have a Clock for its state.
+ *
+ * So the Formatter monitors system settings, the current timezone, etc.
+ * and upate its time format properties appropriately.
+ */
+class Formatter
+{
+public:
+
+    /** \brief The time format string for the menu header */
+    core::Property<std::string> header_format;
+
+    /** \brief The time string for the menu header. (eg, the header_format + the clock's time */
+    core::Property<std::string> header;
+
+    /** \brief Signal to denote when the relativeFormat has changed.
+               When this is emitted, clients will want to rebuild their
+               menuitems that contain relative time strings
+               (ie, the Appointments and Locations menuitems) */
+    core::Signal<> relative_format_changed;
+
+    /** \brief Generate a relative time format for some time (or time range)
+               from the current clock's value. For example, a full-day interval
+               starting at the end of the current clock's day yields "Tomorrow" */
+    std::string relative_format(GDateTime* then, GDateTime* then_end=nullptr) const;
+
+protected:
+    Formatter(const std::shared_ptr<const Clock>&);
+    virtual ~Formatter();
+
+    static const char* default_header_time_format(bool twelvehour, bool show_seconds);
+
+private:
+
+    Formatter(const Formatter&) =delete;
+    Formatter& operator=(const Formatter&) =delete;
+
+    class Impl;
+    std::unique_ptr<Impl> p;
+};
+
+
+/**
+ * \brief A Formatter for the Desktop and DesktopGreeter profiles.
+ */
+class DesktopFormatter: public Formatter
+{
+public:
+    DesktopFormatter(const std::shared_ptr<const Clock>&, const std::shared_ptr<const Settings>&);
+
+private:
+    std::shared_ptr<const Settings> m_settings;
+
+    void rebuildHeaderFormat();
+    const gchar* getFullTimeFormatString() const;
+    std::string getHeaderLabelFormatString() const;
+    const gchar* getDateFormat(bool show_day, bool show_date, bool show_year) const;
+
+};
+
+
+/**
+ * \brief A Formatter for Phone and PhoneGreeter profiles.
+ */
+class PhoneFormatter: public Formatter
+{
+public:
+    PhoneFormatter(const std::shared_ptr<const Clock>& clock): Formatter(clock) {
+        header_format.set(default_header_time_format(is_locale_12h(), false));
+    }
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_CLOCK_H

=== added file 'include/datetime/locations-settings.h'
--- include/datetime/locations-settings.h	1970-01-01 00:00:00 +0000
+++ include/datetime/locations-settings.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_SETTINGS_LOCATIONS_H
+#define INDICATOR_DATETIME_SETTINGS_LOCATIONS_H
+
+#include <datetime/locations.h> // base class
+
+#include <datetime/settings.h>
+#include <datetime/timezones.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief #Locations implementation which builds its list from the #Settings.
+ */
+class SettingsLocations: public Locations
+{
+public:
+    /**
+     * @param[in] settings the #Settings whose locations property is to be used
+     * @param[in] timezones the #Timezones to always show first in the list
+     */
+    SettingsLocations (const std::shared_ptr<const Settings>& settings,
+                       const std::shared_ptr<const Timezones>& timezones);
+
+private:
+    std::shared_ptr<const Settings> m_settings;
+    std::shared_ptr<const Timezones> m_timezones;
+    void reload();
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_SETTINGS_LOCATIONS_H

=== added file 'include/datetime/locations.h'
--- include/datetime/locations.h	1970-01-01 00:00:00 +0000
+++ include/datetime/locations.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_LOCATIONS_H
+#define INDICATOR_DATETIME_LOCATIONS_H
+
+#include <datetime/date-time.h>
+
+#include <core/property.h>
+
+#include <string>
+#include <vector>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief A physical place and its timezone; eg, "America/Chicago" + "Oklahoma City"
+ *
+ * @see Locations
+ */
+class Location
+{
+public:
+    Location (const std::string& zone, const std::string& name);
+    const std::string& zone() const;
+    const std::string& name() const;
+    bool operator== (const Location& that) const;
+
+private:
+
+    /** timezone; eg, "America/Chicago" */
+    std::string m_zone;
+
+    /* human-readable location name; eg, "Oklahoma City" */
+    std::string m_name;
+
+    /** offset from UTC in microseconds */
+    int64_t m_offset = 0;
+};
+
+/**
+ * Container which holds an ordered list of Locations
+ *
+ * @see Location
+ * @see State
+ */
+class Locations
+{
+public:
+    Locations() =default;
+    virtual ~Locations() =default;
+
+    /** \brief an ordered list of Location items */
+    core::Property<std::vector<Location>> locations;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_LOCATIONS_H

=== added file 'include/datetime/menu.h'
--- include/datetime/menu.h	1970-01-01 00:00:00 +0000
+++ include/datetime/menu.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_MENU_H
+#define INDICATOR_DATETIME_MENU_H
+
+#include <datetime/actions.h>
+#include <datetime/state.h>
+
+#include <memory> // std::shared_ptr
+#include <vector>
+
+#include <gio/gio.h> // GMenuModel
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief A menu for a specific profile; eg, Desktop or Phone.
+ *
+ * @see MenuFactory
+ * @see Exporter
+ */
+class Menu
+{
+public:
+    enum Profile { Desktop, DesktopGreeter, Phone, PhoneGreeter, NUM_PROFILES };
+    enum Section { Calendar, Appointments, Locations, Settings, NUM_SECTIONS };
+    const std::string& name() const;
+    Profile profile() const;
+    GMenuModel* menu_model();
+
+protected:
+    Menu (Profile profile_in, const std::string& name_in);
+    virtual ~Menu() =default;
+    GMenu* m_menu = nullptr;
+
+private:
+    const Profile m_profile;
+    const std::string m_name;
+
+    // we've got raw pointers in here, so disable copying
+    Menu(const Menu&) =delete;
+    Menu& operator=(const Menu&) =delete;
+};
+
+/**
+ * \brief Builds a Menu for a given state and profile
+ *
+ * @see Menu
+ * @see Exporter
+ */
+class MenuFactory
+{
+public:
+    MenuFactory (const std::shared_ptr<Actions>& actions, const std::shared_ptr<const State>& state);
+    std::shared_ptr<Menu> buildMenu(Menu::Profile profile);
+
+private:
+    std::shared_ptr<Actions> m_actions;
+    std::shared_ptr<const State> m_state;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_MENU_H

=== added file 'include/datetime/planner-eds.h'
--- include/datetime/planner-eds.h	1970-01-01 00:00:00 +0000
+++ include/datetime/planner-eds.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_PLANNER_EDS_H
+#define INDICATOR_DATETIME_PLANNER_EDS_H
+
+#include <datetime/planner.h>
+
+#include <memory> // unique_ptr
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Planner which uses EDS as its backend
+ */
+class PlannerEds: public Planner
+{
+public:
+    PlannerEds();
+    virtual ~PlannerEds();
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> p;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_PLANNER_EDS_H

=== added file 'include/datetime/planner.h'
--- include/datetime/planner.h	1970-01-01 00:00:00 +0000
+++ include/datetime/planner.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_PLANNER_H
+#define INDICATOR_DATETIME_PLANNER_H
+
+#include <datetime/appointment.h>
+#include <datetime/date-time.h>
+
+#include <core/property.h>
+
+#include <vector>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Simple appointment book
+ *
+ * @see EdsPlanner
+ * @see State
+ */
+class Planner
+{
+public:
+    virtual ~Planner() =default;
+
+    /**
+     * \brief Timestamp used to determine the appointments in the `upcoming' and `this_month' properties.
+     * Setting this value will cause the planner to re-query its backend and
+     * update the `upcoming' and `this_month' properties.
+     */
+    core::Property<DateTime> time;
+
+    /**
+     * \brief The next few appointments that follow the time specified in the time property.
+     */
+    core::Property<std::vector<Appointment>> upcoming;
+
+    /**
+     * \brief The appointments that occur in the same month as the time property
+     */
+    core::Property<std::vector<Appointment>> this_month;
+
+protected:
+    Planner() =default;
+
+private:
+
+    // disable copying
+    Planner(const Planner&) =delete;
+    Planner& operator=(const Planner&) =delete;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_PLANNER_H

=== added file 'include/datetime/settings-live.h'
--- include/datetime/settings-live.h	1970-01-01 00:00:00 +0000
+++ include/datetime/settings-live.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_SETTINGS_LIVE_H
+#define INDICATOR_DATETIME_SETTINGS_LIVE_H
+
+#include <datetime/settings.h> // parent class
+
+#include <gio/gio.h> // GSettings
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief #Settings implementation which uses GSettings.
+ */
+class LiveSettings: public Settings
+{
+public:
+    LiveSettings();
+    virtual ~LiveSettings();
+
+private:
+    static void on_changed(GSettings*, gchar*, gpointer);
+    void update_key(const std::string& key);
+
+    void update_custom_time_format();
+    void update_locations();
+    void update_show_calendar();
+    void update_show_clock();
+    void update_show_date();
+    void update_show_day();
+    void update_show_detected_locations();
+    void update_show_events();
+    void update_show_locations();
+    void update_show_seconds();
+    void update_show_week_numbers();
+    void update_show_year();
+    void update_time_format_mode();
+    void update_timezone_name();
+
+    GSettings* m_settings;
+
+    // we've got a raw pointer here, so disable copying
+    LiveSettings(const LiveSettings&) =delete;
+    LiveSettings& operator=(const LiveSettings&) =delete;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_SETTINGS_LIVE_H

=== added file 'include/datetime/settings-shared.h'
--- include/datetime/settings-shared.h	1970-01-01 00:00:00 +0000
+++ include/datetime/settings-shared.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_SETTINGS_SHARED
+#define INDICATOR_DATETIME_SETTINGS_SHARED
+
+typedef enum
+{
+  TIME_FORMAT_MODE_LOCALE_DEFAULT,
+  TIME_FORMAT_MODE_12_HOUR,
+  TIME_FORMAT_MODE_24_HOUR,
+  TIME_FORMAT_MODE_CUSTOM
+}
+TimeFormatMode;
+
+#define SETTINGS_INTERFACE              "com.canonical.indicator.datetime"
+#define SETTINGS_SHOW_CLOCK_S           "show-clock"
+#define SETTINGS_TIME_FORMAT_S          "time-format"
+#define SETTINGS_SHOW_SECONDS_S         "show-seconds"
+#define SETTINGS_SHOW_DAY_S             "show-day"
+#define SETTINGS_SHOW_DATE_S            "show-date"
+#define SETTINGS_SHOW_YEAR_S            "show-year"
+#define SETTINGS_CUSTOM_TIME_FORMAT_S   "custom-time-format"
+#define SETTINGS_SHOW_CALENDAR_S        "show-calendar"
+#define SETTINGS_SHOW_WEEK_NUMBERS_S    "show-week-numbers"
+#define SETTINGS_SHOW_EVENTS_S          "show-events"
+#define SETTINGS_SHOW_LOCATIONS_S       "show-locations"
+#define SETTINGS_SHOW_DETECTED_S        "show-auto-detected-location"
+#define SETTINGS_LOCATIONS_S            "locations"
+#define SETTINGS_TIMEZONE_NAME_S        "timezone-name"
+
+#endif // INDICATOR_DATETIME_SETTINGS_SHARED

=== added file 'include/datetime/settings.h'
--- include/datetime/settings.h	1970-01-01 00:00:00 +0000
+++ include/datetime/settings.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_SETTINGS_H
+#define INDICATOR_DATETIME_SETTINGS_H
+
+#include <datetime/settings-shared.h>
+
+#include <core/property.h>
+
+#include <vector>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Interface that represents user-configurable settings.
+ *
+ * See the descriptions in data/com.canonical.indicator.datetime.gschema.xml
+ * for more information on specific properties.
+ */
+class Settings 
+{
+public:
+    Settings() =default;
+    virtual ~Settings() =default;
+
+    core::Property<std::string> custom_time_format;
+    core::Property<std::vector<std::string>> locations;
+    core::Property<bool> show_calendar;
+    core::Property<bool> show_clock;
+    core::Property<bool> show_date;
+    core::Property<bool> show_day;
+    core::Property<bool> show_detected_location;
+    core::Property<bool> show_events;
+    core::Property<bool> show_locations;
+    core::Property<bool> show_seconds;
+    core::Property<bool> show_week_numbers;
+    core::Property<bool> show_year;
+    core::Property<TimeFormatMode> time_format_mode;
+    core::Property<std::string> timezone_name;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_SETTINGS_H

=== added file 'include/datetime/state.h'
--- include/datetime/state.h	1970-01-01 00:00:00 +0000
+++ include/datetime/state.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_STATE_H
+#define INDICATOR_DATETIME_STATE_H
+
+#include <datetime/clock.h>
+#include <datetime/locations.h>
+#include <datetime/planner.h>
+#include <datetime/settings.h>
+#include <datetime/timezones.h>
+   
+#include <core/property.h>
+
+#include <memory> // std::shared_ptr
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Aggregates all the classes that represent the backend state.
+ *
+ * This is where the app comes together. It's a model that aggregates
+ * all of the backend appointments/alarms, locations, timezones,
+ * system time, and so on. The "view" code (ie, the Menus) need to
+ * respond to Signals from the State and update themselves accordingly.
+ *
+ * @see Menu
+ * @see MenuFactory
+ * @see Timezones
+ * @see Clock
+ * @see Planner
+ * @see Locations
+ * @see Settings
+ */
+struct State
+{
+    /** \brief The current time. Used by the header, by the date menuitem,
+               and by the locations for relative timestamp */
+    std::shared_ptr<Clock> clock;
+
+    /** \brief The locations to be displayed in the Locations
+               section of the #Menu */
+    std::shared_ptr<Locations> locations;
+
+    /** \brief The appointments to be displayed in the Calendar and
+               Appointments sections of the #Menu */
+    std::shared_ptr<Planner> planner;
+
+    /** \brief Configuration options that modify the view */
+    std::shared_ptr<Settings> settings;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_STATE_H

=== added file 'include/datetime/timezone-file.h'
--- include/datetime/timezone-file.h	1970-01-01 00:00:00 +0000
+++ include/datetime/timezone-file.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_FILE_TIMEZONE_H
+#define INDICATOR_DATETIME_FILE_TIMEZONE_H
+
+#include <datetime/timezone.h> // base class
+
+#include <string> // std::string
+
+#include <glib.h>
+#include <gio/gio.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief A #Timezone that gets its information from monitoring a file, such as /etc/timezone
+ */
+class FileTimezone: public Timezone
+{
+public:
+    FileTimezone();
+    FileTimezone(const std::string& filename);
+    ~FileTimezone();
+
+private:
+    void setFilename(const std::string& filename);
+    static void onFileChanged(gpointer gself);
+    void clear();
+    void reload();
+
+    std::string m_filename;
+    GFileMonitor * m_monitor = nullptr;
+    unsigned long m_monitor_handler_id = 0;
+
+    // we have raw pointers and glib tags in here, so disable copying
+    FileTimezone(const FileTimezone&) =delete;
+    FileTimezone& operator=(const FileTimezone&) =delete;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_FILE_TIMEZONE_H

=== added file 'include/datetime/timezone-geoclue.h'
--- include/datetime/timezone-geoclue.h	1970-01-01 00:00:00 +0000
+++ include/datetime/timezone-geoclue.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_GEOCLUE_TIMEZONE_H
+#define INDICATOR_DATETIME_GEOCLUE_TIMEZONE_H
+
+#include <datetime/timezone.h> // base class
+
+#include <string>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief A #Timezone that gets its information from asking GeoClue
+ */
+class GeoclueTimezone: public Timezone
+{
+public:
+    GeoclueTimezone();
+    ~GeoclueTimezone();
+
+private:
+    static void on_bus_got (GObject*, GAsyncResult*, gpointer);
+    static void on_client_created (GObject*, GAsyncResult*, gpointer);
+    static void on_address_changed (GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant*, gpointer);
+    static void on_requirements_set (GObject*, GAsyncResult*, gpointer);
+    static void on_address_started (GObject*, GAsyncResult*, gpointer);
+    static void on_address_got (GObject*, GAsyncResult*, gpointer);
+    void setTimezoneFromAddressVariant (GVariant*);
+    static GVariant * call_finish (GObject*, GAsyncResult*);
+
+    GCancellable * m_cancellable = nullptr;
+    GDBusConnection * m_connection = nullptr;
+    std::string m_client_object_path;
+    guint m_signal_subscription = 0;
+
+    // we've got pointers and gsignal tags in here, so don't allow copying
+    GeoclueTimezone(const GeoclueTimezone&) =delete;
+    GeoclueTimezone& operator=(const GeoclueTimezone&) =delete;
+};
+
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_GEOCLUE_TIMEZONE_H
+

=== added file 'include/datetime/timezone.h'
--- include/datetime/timezone.h	1970-01-01 00:00:00 +0000
+++ include/datetime/timezone.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_TIMEZONE_H
+#define INDICATOR_DATETIME_TIMEZONE_H
+
+#include <core/property.h>
+
+#include <string>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/** \brief Base a timezone, such as "America/Chicago". */
+class Timezone
+{
+protected:
+    Timezone() =default;
+
+public:
+    core::Property<std::string> timezone;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_TIMEZONE_H

=== added file 'include/datetime/timezones-live.h'
--- include/datetime/timezones-live.h	1970-01-01 00:00:00 +0000
+++ include/datetime/timezones-live.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_LIVE_TIMEZONES_H
+#define INDICATOR_DATETIME_LIVE_TIMEZONES_H
+
+#include <datetime/settings.h>
+#include <datetime/timezones.h>
+#include <datetime/timezone-file.h>
+#include <datetime/timezone-geoclue.h>
+
+#include <memory> // shared_ptr<>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief #Timezones object that uses a #FileTimezone and #GeoclueTimezone
+ *        to detect what timezone we're in
+ */
+class LiveTimezones: public Timezones
+{
+public:
+    LiveTimezones(const std::shared_ptr<const Settings>& settings, const std::string& filename);
+
+private:
+    void update_geolocation();
+    void update_timezones();
+
+    FileTimezone m_file;
+    std::shared_ptr<const Settings> m_settings;
+    std::shared_ptr<GeoclueTimezone> m_geo;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_LIVE_TIMEZONES_H

=== added file 'include/datetime/timezones.h'
--- include/datetime/timezones.h	1970-01-01 00:00:00 +0000
+++ include/datetime/timezones.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_TIMEZONES_H
+#define INDICATOR_DATETIME_TIMEZONES_H
+
+#include <datetime/timezone.h>
+
+#include <core/property.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/**
+ * \brief Helper class which aggregates one or more timezones
+ *
+ * @see LiveClock
+ * @see SettingsLocations
+ */
+class Timezones
+{
+public:
+    Timezones() =default;
+    virtual ~Timezones() =default;
+
+    /**
+     * \brief the current timezone
+     */
+    core::Property<std::string> timezone;
+
+    /**
+     * \brief all the detected timezones.
+     * The count is >1 iff the detection mechamisms disagree.
+     */
+    core::Property<std::set<std::string> > timezones;
+};
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_TIMEZONES_H

=== added file 'include/datetime/utils.h'
--- include/datetime/utils.h	1970-01-01 00:00:00 +0000
+++ include/datetime/utils.h	2014-01-31 00:43:10 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010, 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Michael Terry <[e-mail]>
+ *   Charles Kerr <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_UTILS_H
+#define INDICATOR_DATETIME_UTILS_H
+
+#include <glib.h>
+#include <gio/gio.h> /* GSettings */
+
+G_BEGIN_DECLS
+
+/** \brief Returns true if the current locale prefers 12h display instead of 24h */
+gboolean      is_locale_12h                        (void);
+
+void          split_settings_location              (const char  * location,
+                                                    char       ** zone,
+                                                    char       ** name);
+
+gchar *       get_timezone_name                    (const char  * timezone,
+                                                    GSettings   * settings);
+
+gchar *       get_beautified_timezone_name         (const char  * timezone,
+                                                    const char  * saved_location);
+
+gchar *       generate_full_format_string_at_time  (GDateTime   * now,
+                                                    GDateTime   * then_begin,
+                                                    GDateTime   * then_end);
+
+/** \brief Translate the string based on LC_TIME instead of LC_MESSAGES.
+           The intent of this is to let users set LC_TIME to override
+           their other locale settings when generating time format string */
+const char*   T_                                   (const char  * msg);
+
+  
+G_END_DECLS
+
+#endif /* INDICATOR_DATETIME_UTILS_H */

=== modified file 'panel-gnome/CMakeLists.txt'
--- panel-gnome/CMakeLists.txt	2014-01-10 01:45:41 +0000
+++ panel-gnome/CMakeLists.txt	2014-01-31 00:43:10 +0000
@@ -2,16 +2,20 @@
 
 add_definitions (-DPKGDATADIR="${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATADIR}/${CMAKE_PROJECT_NAME}")
 
+
+SET (CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -std=c99   -g")
+SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g ${CXX_WARNING_ARGS}")
+
 add_library (${PANEL_LIB} SHARED
              ${CMAKE_SOURCE_DIR}/panel/datetime-prefs.c 
              ${CMAKE_SOURCE_DIR}/panel/datetime-prefs-locations.c
              ${CMAKE_SOURCE_DIR}/panel/datetime-prefs-locations.h
              ${CMAKE_SOURCE_DIR}/src/utils.c
-             ${CMAKE_SOURCE_DIR}/src/utils.h
-             ${CMAKE_SOURCE_DIR}/src/settings-shared.h)
+             ${CMAKE_SOURCE_DIR}/include/datetime/utils.h
+             ${CMAKE_SOURCE_DIR}/include/datetime/settings-shared.h)
 set_property (TARGET ${PANEL_LIB} PROPERTY OUTPUT_NAME indicator-datetime)
 
-include_directories (${PANEL_DEPS_INCLUDE_DIRS})
+include_directories (SYSTEM ${PANEL_DEPS_INCLUDE_DIRS})
 
 link_directories (${PANEL_DEPS_LIBRARY_DIRS})
 

=== modified file 'panel-unity/CMakeLists.txt'
--- panel-unity/CMakeLists.txt	2014-01-10 01:45:41 +0000
+++ panel-unity/CMakeLists.txt	2014-01-31 00:43:10 +0000
@@ -2,16 +2,19 @@
 
 add_definitions (-DPKGDATADIR="${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATADIR}/${CMAKE_PROJECT_NAME}")
 
+SET (CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -std=c99   -g")
+SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g ${CXX_WARNING_ARGS}")
+
 add_library (${PANEL_LIB} SHARED
              ${CMAKE_SOURCE_DIR}/panel/datetime-prefs.c 
              ${CMAKE_SOURCE_DIR}/panel/datetime-prefs-locations.c
              ${CMAKE_SOURCE_DIR}/panel/datetime-prefs-locations.h
              ${CMAKE_SOURCE_DIR}/src/utils.c
-             ${CMAKE_SOURCE_DIR}/src/utils.h
-             ${CMAKE_SOURCE_DIR}/src/settings-shared.h)
+             ${CMAKE_SOURCE_DIR}/include/datetime/utils.h
+             ${CMAKE_SOURCE_DIR}/include/datetime/settings-shared.h)
 set_property (TARGET ${PANEL_LIB} PROPERTY OUTPUT_NAME indicator-datetime)
 
-include_directories (${UNITY_PANEL_DEPS_INCLUDE_DIRS})
+include_directories (SYSTEM ${UNITY_PANEL_DEPS_INCLUDE_DIRS})
 
 link_directories (${UNITY_PANEL_DEPS_LIBRARY_DIRS})
 

=== modified file 'panel/datetime-prefs-locations.c'
--- panel/datetime-prefs-locations.c	2014-01-29 18:49:55 +0000
+++ panel/datetime-prefs-locations.c	2014-01-31 00:43:10 +0000
@@ -24,20 +24,23 @@
 #include "config.h"
 #endif
 
+#include "datetime-prefs-locations.h"
+
+#include <datetime/settings-shared.h>
+#include <datetime/utils.h>
+
+#include <timezonemap/timezone-completion.h>
+
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+
 #include <stdlib.h>
 #include <time.h> /* time_t */
-#include <glib/gi18n-lib.h>
-#include <gtk/gtk.h>
-#include <timezonemap/timezone-completion.h>
-
-#include "datetime-prefs-locations.h"
-#include "settings-shared.h"
-#include "utils.h"
 
 #if USE_UNITY
-#define DATETIME_DIALOG_UI_FILE PKGDATADIR "/unity-control-center/datetime-dialog.ui"
+ #define DATETIME_DIALOG_UI_FILE PKGDATADIR "/unity-control-center/datetime-dialog.ui"
 #else
-#define DATETIME_DIALOG_UI_FILE PKGDATADIR "/gnome-control-center/datetime-dialog.ui"
+ #define DATETIME_DIALOG_UI_FILE PKGDATADIR "/gnome-control-center/datetime-dialog.ui"
 #endif
 
 #define COL_NAME         0
@@ -314,7 +317,7 @@
 
     gtk_list_store_set (store, &iter,
                         COL_VISIBLE_NAME, new_text,
-                        COL_ICON, correct ? NULL : GTK_STOCK_DIALOG_ERROR,
+                        COL_ICON, correct ? NULL : "dialog-error",
                         -1);
   }
 }
@@ -429,7 +432,6 @@
 
   g_signal_handlers_block_by_func (store, save_when_idle, dlg);
 
-  GSettings * settings = g_settings_new (SETTINGS_INTERFACE);
   GtkTreeIter iter;
   if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter)) {
     GDateTime * now = g_date_time_new_now_local ();
@@ -441,7 +443,7 @@
       if (strzone && *strzone) {
         GTimeZone * tz = g_time_zone_new (strzone);
         GDateTime * now_tz = g_date_time_to_timezone (now, tz);
-        gchar * format = generate_full_format_string_at_time (now, now_tz, settings);
+        gchar * format = generate_full_format_string_at_time (now, now_tz, NULL);
         gchar * time_str = g_date_time_format (now_tz, format);
         gchar * old_time_str;
 
@@ -460,8 +462,6 @@
     g_date_time_unref (now);
   }
 
-  g_object_unref (settings);
-
   g_signal_handlers_unblock_by_func (store, save_when_idle, dlg);
 
   return TRUE;

=== modified file 'panel/datetime-prefs.c'
--- panel/datetime-prefs.c	2014-01-10 01:45:41 +0000
+++ panel/datetime-prefs.c	2014-01-31 00:43:10 +0000
@@ -25,26 +25,30 @@
 #include "config.h"
 #endif
 
+#include "datetime-prefs-locations.h"
+
+#include <datetime/dbus-shared.h>
+#include <datetime/settings-shared.h>
+#include <datetime/utils.h>
+
+#include <polkit/polkit.h>
+#include <timezonemap/cc-timezone-map.h>
+#include <timezonemap/timezone-completion.h>
+
+#include <glib/gi18n-lib.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+
+#ifdef USE_UNITY
+ #include <libunity-control-center/cc-panel.h>
+#else
+ #include <libgnome-control-center/cc-panel.h>
+#endif
+
 #include <stdlib.h>
 #include <libintl.h>
 #include <locale.h>
 #include <langinfo.h>
-#include <glib/gi18n-lib.h>
-#include <gdk/gdkkeysyms.h>
-#include <gtk/gtk.h>
-#include <polkit/polkit.h>
-#if USE_UNITY
-#include <libunity-control-center/cc-panel.h>
-#else
-#include <libgnome-control-center/cc-panel.h>
-#endif
-#include <timezonemap/cc-timezone-map.h>
-#include <timezonemap/timezone-completion.h>
-
-#include "dbus-shared.h"
-#include "settings-shared.h"
-#include "utils.h"
-#include "datetime-prefs-locations.h"
 
 #if USE_UNITY
 #define DATETIME_DIALOG_UI_FILE PKGDATADIR "/unity-control-center/datetime-dialog.ui"
@@ -225,12 +229,12 @@
 static void
 sync_entry (IndicatorDatetimePanel * self, const gchar * location)
 {
-  gchar * name = get_current_zone_name (location, self->priv->settings);
+  gchar * name = get_timezone_name (location, self->priv->settings);
   gtk_entry_set_text (GTK_ENTRY (self->priv->tz_entry), name);
   g_free (name);
 
-  gtk_entry_set_icon_from_stock (GTK_ENTRY (self->priv->tz_entry),
-                                 GTK_ENTRY_ICON_SECONDARY, NULL);
+  gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->priv->tz_entry),
+                                     GTK_ENTRY_ICON_SECONDARY, NULL);
 }
 
 static void
@@ -295,10 +299,10 @@
     {
       if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
         {
-          const gchar *timezone = g_variant_get_string (value, NULL);
+          const gchar * str = g_variant_get_string (value, NULL);
 
-          cc_timezone_map_set_timezone (priv->tzmap, timezone);
-          sync_entry (self, timezone);
+          cc_timezone_map_set_timezone (priv->tzmap, str);
+          sync_entry (self, str);
           g_signal_connect (priv->tzmap, "location-changed", G_CALLBACK (tz_changed), self);
         }
       g_variant_unref (value);
@@ -640,13 +644,13 @@
   gchar * zone;
   g_object_get (location, "zone", &zone, NULL);
 
-  gchar * name = get_current_zone_name (zone, self->priv->settings);
+  gchar * name = get_timezone_name (zone, self->priv->settings);
   gboolean correct = (g_strcmp0 (gtk_entry_get_text (entry), name) == 0);
   g_free (name);
   g_free (zone);
 
-  gtk_entry_set_icon_from_stock (entry, GTK_ENTRY_ICON_SECONDARY,
-                                 correct ? NULL : GTK_STOCK_DIALOG_ERROR);
+  gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY,
+                                     correct ? NULL : "dialog-error");
   gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY,
                                    _("You need to choose a location to change the time zone."));
   gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, FALSE);

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2014-01-10 01:45:41 +0000
+++ po/POTFILES.in	2014-01-31 00:43:10 +0000
@@ -1,6 +1,6 @@
-src/service.c
-src/settings-shared.h
-src/utils.c
+src/formatter.cpp
+src/formatter-desktop.cpp
+src/menu.cpp
 panel/datetime-prefs.c
 panel/datetime-prefs-locations.c
 [type: gettext/glade]data/datetime-dialog.ui

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2013-12-13 15:44:46 +0000
+++ src/CMakeLists.txt	2014-01-31 00:43:10 +0000
@@ -1,6 +1,9 @@
 set (SERVICE_LIB "indicatordatetimeservice")
 set (SERVICE_EXEC "indicator-datetime-service")
 
+SET (CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -std=c99   -g ${CXX_WARNING_ARGS} ${GCOV_FLAGS}")
+SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g ${CXX_WARNING_ARGS} ${GCOV_FLAGS}")
+
 add_definitions (-DTIMEZONE_FILE="/etc/timezone"
                  -DG_LOG_DOMAIN="Indicator-Datetime")
 
@@ -10,36 +13,28 @@
 endif ()
 
 add_library (${SERVICE_LIB} STATIC
-             clock.c
-             clock.h
-             clock-live.c
-             clock-live.h
-             planner.c
-             planner.h
-             planner-eds.c
-             planner-eds.h
-             service.c
-             service.h
-             timezone.c
-             timezone.h
-             timezone-file.c
-             timezone-file.h
-             timezone-geoclue.c
-             timezone-geoclue.h
-             utils.c
-             utils.h
-             dbus-shared.h
-             settings-shared.h)
-include_directories (${SERVICE_DEPS_INCLUDE_DIRS})
+             actions.cpp
+             actions-live.cpp
+             appointment.cpp
+             clock.cpp
+             clock-live.cpp
+             date-time.cpp
+             exporter.cpp
+             formatter.cpp
+             formatter-desktop.cpp
+             locations.cpp
+             locations-settings.cpp
+             menu.cpp
+             planner-eds.cpp
+             settings-live.cpp
+             timezone-file.cpp
+             timezone-geoclue.cpp
+             timezones-live.cpp
+             utils.c)
+include_directories (${CMAKE_SOURCE_DIR})
 link_directories (${SERVICE_DEPS_LIBRARY_DIRS})
 
-add_executable (${SERVICE_EXEC} main.c)
+add_executable (${SERVICE_EXEC} main.cpp)
 target_link_libraries (${SERVICE_EXEC} ${SERVICE_LIB} ${SERVICE_DEPS_LIBRARIES} ${GCOV_LIBS})
 install (TARGETS ${SERVICE_EXEC} RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR})
 
-# common properties
-set_property (TARGET ${SERVICE_LIB} ${SERVICE_EXEC}
-              APPEND_STRING PROPERTY COMPILE_FLAGS
-              " -g ${CC_WARNING_ARGS} ${GCOV_FLAGS}")
-
-

=== added file 'src/actions-live.cpp'
--- src/actions-live.cpp	1970-01-01 00:00:00 +0000
+++ src/actions-live.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/actions-live.h>
+
+#include <url-dispatcher.h>
+
+#include <glib.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+LiveActions::LiveActions(const std::shared_ptr<State>& state_in):
+    Actions(state_in)
+{
+}
+
+void LiveActions::execute_command(const std::string& cmdstr)
+{
+    const auto cmd = cmdstr.c_str();
+    g_debug("Issuing command '%s'", cmd);
+
+    GError* error = nullptr;
+    if (!g_spawn_command_line_async(cmd, &error))
+    {
+        g_warning("Unable to start \"%s\": %s", cmd, error->message);
+        g_error_free(error);
+    }
+}
+
+void LiveActions::dispatch_url(const std::string& url)
+{
+    url_dispatch_send(url.c_str(), nullptr, nullptr);
+}
+
+/***
+****
+***/
+
+void LiveActions::open_desktop_settings()
+{
+    auto path = g_find_program_in_path("unity-control-center");
+
+    if ((path != nullptr) && (g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "Unity") == 0))
+    {
+        execute_command("unity-control-center datetime");       
+    }
+    else
+    {
+#ifdef HAVE_CCPANEL
+        execute_command("gnome-control-center indicator-datetime");
+#else
+        execute_command("gnome-control-center datetime");
+#endif
+    }
+
+    g_free (path);
+}
+
+void LiveActions::open_planner()
+{
+    execute_command("evolution -c calendar");
+}
+
+void LiveActions::open_phone_settings()
+{
+    dispatch_url("settings:///system/time-date");
+}
+
+void LiveActions::open_phone_clock_app()
+{
+    dispatch_url("appid://com.ubuntu.clock/clock/current-user-version");
+}
+
+void LiveActions::open_planner_at(const DateTime& dt)
+{
+    auto cmd = dt.format("evolution \"calendar:///?startdate=%Y%m%d\"");
+    execute_command(cmd.c_str());
+}
+
+void LiveActions::open_appointment(const std::string& uid)
+{
+    for(const auto& appt : state()->planner->upcoming.get())
+    {
+        if(appt.uid != uid)
+            continue;
+
+        if (!appt.url.empty())
+            dispatch_url(appt.url);
+        break;
+    }
+}
+
+/***
+****
+***/
+
+namespace
+{
+
+struct setlocation_data
+{
+  std::string tzid;
+  std::string name;
+  std::shared_ptr<Settings> settings;
+};
+
+static void
+on_datetime1_set_timezone_response(GObject       * object,
+                                   GAsyncResult  * res,
+                                   gpointer        gdata)
+{
+  GError* err = nullptr;
+  auto response = g_dbus_proxy_call_finish(G_DBUS_PROXY(object), res, &err);
+  auto data = static_cast<struct setlocation_data*>(gdata);
+
+  if (err != nullptr)
+    {
+      if (!g_error_matches(err, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning("Could not set new timezone: %s", err->message);
+
+      g_error_free(err);
+    }
+  else
+    {
+      data->settings->timezone_name.set(data->tzid + " " + data->name);
+      g_variant_unref(response);
+    }
+
+  delete data;
+}
+
+static void
+on_datetime1_proxy_ready (GObject      * object G_GNUC_UNUSED,
+                          GAsyncResult * res,
+                          gpointer       gdata)
+{
+  auto data = static_cast<struct setlocation_data*>(gdata);
+
+  GError * err = nullptr;
+  auto proxy = g_dbus_proxy_new_for_bus_finish(res, &err);
+  if (err != NULL)
+    {
+      if (!g_error_matches(err, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning("Could not grab DBus proxy for timedated: %s", err->message);
+
+      g_error_free(err);
+
+      delete data;
+    }
+  else
+    {
+      g_dbus_proxy_call(proxy,
+                        "SetTimezone",
+                        g_variant_new ("(sb)", data->tzid.c_str(), TRUE),
+                        G_DBUS_CALL_FLAGS_NONE,
+                        -1,
+                        nullptr,
+                        on_datetime1_set_timezone_response,
+                        data);
+
+      g_object_unref (proxy);
+    }
+}
+
+} // unnamed namespace
+
+
+void LiveActions::set_location(const std::string& tzid, const std::string& name)
+{
+    g_return_if_fail(!tzid.empty());
+    g_return_if_fail(!name.empty());
+
+    auto data = new struct setlocation_data;
+    data->tzid = tzid;
+    data->name = name;
+    data->settings = state()->settings;
+
+    g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
+                              G_DBUS_PROXY_FLAGS_NONE,
+                              nullptr,
+                              "org.freedesktop.timedate1",
+                              "/org/freedesktop/timedate1",
+                              "org.freedesktop.timedate1",
+                              nullptr,
+                              on_datetime1_proxy_ready,
+                              data);
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== added file 'src/actions.cpp'
--- src/actions.cpp	1970-01-01 00:00:00 +0000
+++ src/actions.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/actions.h>
+#include <datetime/utils.h> // split_settings_location()
+
+#include <glib.h>
+#include <gio/gio.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+namespace
+{
+
+void on_desktop_settings_activated(GSimpleAction * /*action*/,
+                                   GVariant      * /*param*/,
+                                   gpointer        gself)
+{
+    static_cast<Actions*>(gself)->open_desktop_settings();
+}
+
+void on_phone_settings_activated(GSimpleAction * /*action*/,
+                                 GVariant      * /*param*/,
+                                 gpointer        gself)
+{
+    static_cast<Actions*>(gself)->open_phone_settings();
+}
+
+void on_phone_clock_activated(GSimpleAction * /*action*/,
+                              GVariant      * /*param*/,
+                              gpointer        gself)
+{
+    static_cast<Actions*>(gself)->open_phone_clock_app();
+}
+
+void on_activate_appointment(GSimpleAction * /*action*/,
+                             GVariant      * param,
+                             gpointer        gself)
+{
+    const auto uid = g_variant_get_string(param, nullptr);
+    auto self = static_cast<Actions*>(gself);
+
+    g_return_if_fail(uid && *uid);
+
+    // find url of the upcoming appointment with this uid
+    for (const auto& appt : self->state()->planner->upcoming.get())
+    {
+        if (appt.uid == uid)
+        {
+            const auto url = appt.url;
+            g_debug("%s: uid[%s] -> url[%s]", G_STRFUNC, uid, url.c_str());
+            self->open_appointment(url);
+            break;
+        }
+    }
+}
+
+void on_activate_planner(GSimpleAction * /*action*/,
+                         GVariant      * param,
+                         gpointer        gself)
+{
+    const auto at = g_variant_get_int64(param);
+    auto self = static_cast<Actions*>(gself);
+
+    if (at)
+    {
+        auto gdt = g_date_time_new_from_unix_local(at);
+        self->open_planner_at(DateTime(gdt));
+        g_date_time_unref(gdt);
+    }
+    else // no time specified...
+    {
+        self->open_planner();
+    }
+}
+
+void on_set_location(GSimpleAction * /*action*/,
+                     GVariant      * param,
+                     gpointer        gself)
+{
+    char * zone;
+    char * name;
+    split_settings_location(g_variant_get_string(param, nullptr), &zone, &name);
+    static_cast<Actions*>(gself)->set_location(zone, name);
+    g_free(name);
+    g_free(zone);
+}
+
+void on_calendar_active_changed(GSimpleAction * /*action*/,
+                                GVariant      * state,
+                                gpointer        gself)
+{
+    // reset the date when the menu is shown
+    if (g_variant_get_boolean(state))
+    {
+        auto self = static_cast<Actions*>(gself);
+
+        self->set_calendar_date(self->state()->clock->localtime());
+    }
+}
+
+void on_calendar_activated(GSimpleAction * /*action*/,
+                           GVariant      * state,
+                           gpointer        gself)
+{
+    const time_t t = g_variant_get_int64(state);
+
+    g_return_if_fail(t != 0);
+
+    static_cast<Actions*>(gself)->set_calendar_date(DateTime(t));
+}
+
+GVariant* create_default_header_state()
+{
+    GVariantBuilder b;
+    g_variant_builder_init(&b, G_VARIANT_TYPE_VARDICT);
+    g_variant_builder_add(&b, "{sv}", "accessible-desc", g_variant_new_string("accessible-desc"));
+    g_variant_builder_add(&b, "{sv}", "label", g_variant_new_string("label"));
+    g_variant_builder_add(&b, "{sv}", "title", g_variant_new_string("title"));
+    g_variant_builder_add(&b, "{sv}", "visible", g_variant_new_boolean(true));
+    return g_variant_builder_end(&b);
+}
+
+GVariant* create_calendar_state(const std::shared_ptr<State>& state)
+{
+    gboolean days[32] = { 0 };
+    for (const auto& appt : state->planner->this_month.get())
+        days[appt.begin.day_of_month()] = true;
+
+    GVariantBuilder day_builder;
+    g_variant_builder_init(&day_builder, G_VARIANT_TYPE("ai"));
+    for (guint i=0; i<G_N_ELEMENTS(days); i++)
+        if (days[i])
+            g_variant_builder_add(&day_builder, "i", i);
+
+    GVariantBuilder dict_builder;
+    g_variant_builder_init(&dict_builder, G_VARIANT_TYPE_DICTIONARY);
+
+    auto key = "appointment-days";
+    auto v = g_variant_builder_end(&day_builder);
+    g_variant_builder_add(&dict_builder, "{sv}", key, v);
+
+    key = "calendar-day";
+    v = g_variant_new_int64(state->planner->time.get().to_unix());
+    g_variant_builder_add(&dict_builder, "{sv}", key, v);
+
+    key = "show-week-numbers";
+    v = g_variant_new_boolean(state->settings->show_week_numbers.get());
+    g_variant_builder_add(&dict_builder, "{sv}", key, v);
+
+    return g_variant_builder_end(&dict_builder);
+}
+} // unnamed namespace
+
+/***
+****
+***/
+
+Actions::Actions(const std::shared_ptr<State>& state):
+    m_state(state),
+    m_actions(g_simple_action_group_new())
+{
+    GActionEntry entries[] = {
+        { "activate-desktop-settings", on_desktop_settings_activated },
+        { "activate-phone-settings", on_phone_settings_activated },
+        { "activate-phone-clock-app", on_phone_clock_activated },
+        { "activate-appointment", on_activate_appointment, "s", nullptr },
+        { "activate-planner", on_activate_planner, "x", nullptr },
+        { "calendar-active", nullptr, nullptr, "false", on_calendar_active_changed },
+        { "set-location", on_set_location, "s" }
+    };
+
+    g_action_map_add_action_entries(G_ACTION_MAP(m_actions),
+                                    entries,
+                                    G_N_ELEMENTS(entries),
+                                    this);
+
+    // add the header actions
+    auto gam = G_ACTION_MAP(m_actions);
+    auto v = create_default_header_state();
+    auto a = g_simple_action_new_stateful("desktop-header", nullptr, v);
+    g_action_map_add_action(gam, G_ACTION(a));
+    a = g_simple_action_new_stateful("desktop_greeter-header", nullptr, v);
+    g_action_map_add_action(gam, G_ACTION(a));
+    a = g_simple_action_new_stateful("phone-header", nullptr, v);
+    g_action_map_add_action(gam, G_ACTION(a));
+    a = g_simple_action_new_stateful("phone_greeter-header", nullptr, v);
+    g_action_map_add_action(gam, G_ACTION(a));
+
+    // add the calendar action
+    v = create_calendar_state(state);
+    a = g_simple_action_new_stateful("calendar", G_VARIANT_TYPE_INT64, v);
+    g_action_map_add_action(gam, G_ACTION(a));
+    g_signal_connect(a, "activate", G_CALLBACK(on_calendar_activated), this);
+
+    ///
+    ///  Keep our GActionGroup's action's states in sync with m_state
+    ///
+
+    m_state->planner->time.changed().connect([this](const DateTime&){
+        update_calendar_state();
+    });
+    m_state->planner->this_month.changed().connect([this](const std::vector<Appointment>&){
+        update_calendar_state();
+    });
+    m_state->settings->show_week_numbers.changed().connect([this](bool){
+        update_calendar_state();
+    });
+
+    // FIXME: rebuild the calendar state when show-week-number changes
+}
+
+Actions::~Actions()
+{
+    g_clear_object(&m_actions);
+}
+
+void Actions::update_calendar_state()
+{
+    g_action_group_change_action_state(action_group(),
+                                       "calendar",
+                                       create_calendar_state(m_state));
+}
+
+void Actions::set_calendar_date(const DateTime& date)
+{
+    m_state->planner->time.set(date);
+}
+
+GActionGroup* Actions::action_group()
+{
+    return G_ACTION_GROUP(m_actions);
+}
+
+const std::shared_ptr<State> Actions::state() const
+{
+    return m_state;
+}
+
+
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== added file 'src/appointment.cpp'
--- src/appointment.cpp	1970-01-01 00:00:00 +0000
+++ src/appointment.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/appointment.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/****
+*****
+****/
+
+bool Appointment::operator==(const Appointment& that) const
+{
+    return (color==that.color)
+        && (summary==that.summary)
+        && (url==that.url)
+        && (uid==that.uid)
+        && (is_event==that.is_event)
+        && (has_alarms==that.has_alarms)
+        && (begin==that.begin)
+        && (end==that.end);
+}
+
+/****
+*****
+****/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== removed file 'src/clock-live.c'
--- src/clock-live.c	2013-11-14 22:52:32 +0000
+++ src/clock-live.c	1970-01-01 00:00:00 +0000
@@ -1,278 +0,0 @@
-/*
- * Copyright 2013 Canonical Ltd.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <glib.h>
-#include <gio/gio.h>
-
-#include "clock-live.h"
-#include "settings-shared.h"
-#include "timezone-file.h"
-#include "timezone-geoclue.h"
-
-/***
-****  private struct
-***/
-
-struct _IndicatorDatetimeClockLivePriv
-{
-  GSettings * settings;
-
-  GSList * timezones; /* IndicatorDatetimeTimezone */
-  gchar ** timezones_strv;
-  GTimeZone * localtime_zone;
-};
-
-typedef IndicatorDatetimeClockLivePriv priv_t;
-
-/***
-****  GObject boilerplate
-***/
-
-static void indicator_datetime_clock_interface_init (
-                                IndicatorDatetimeClockInterface * iface);
-
-G_DEFINE_TYPE_WITH_CODE (
-  IndicatorDatetimeClockLive,
-  indicator_datetime_clock_live,
-  G_TYPE_OBJECT,
-  G_IMPLEMENT_INTERFACE (INDICATOR_TYPE_DATETIME_CLOCK,
-                         indicator_datetime_clock_interface_init))
-
-/***
-****  Timezones
-***/
-
-static void
-on_current_timezone_changed (IndicatorDatetimeClockLive * self)
-{
-  priv_t * p = self->priv;
-
-  /* Invalidate the timezone information.
-     These fields will be lazily regenerated by rebuild_timezones() */
-  g_clear_pointer (&p->timezones_strv, g_strfreev);
-  g_clear_pointer (&p->localtime_zone, g_time_zone_unref);
-
-  indicator_datetime_clock_emit_changed (INDICATOR_DATETIME_CLOCK (self));
-}
-
-static void
-set_detect_location_enabled (IndicatorDatetimeClockLive * self, gboolean enabled)
-{
-  GSList * l;
-  priv_t * p = self->priv;
-  gboolean changed = FALSE;
-
-  /* clear out the old timezone objects */
-  if (p->timezones != NULL)
-    {
-      for (l=p->timezones; l!=NULL; l=l->next)
-        {
-          g_signal_handlers_disconnect_by_func (l->data, on_current_timezone_changed, self);
-          g_object_unref (l->data);
-        }
-
-      g_slist_free (p->timezones);
-      p->timezones = NULL;
-      changed = TRUE;
-    }
-
-  /* maybe add new timezone objects */
-  if (enabled)
-    {
-      p->timezones = g_slist_append (p->timezones, indicator_datetime_timezone_geoclue_new ());
-      p->timezones = g_slist_append (p->timezones, indicator_datetime_timezone_file_new (TIMEZONE_FILE));
-
-      for (l=p->timezones; l!=NULL; l=l->next)
-        {
-          g_signal_connect_swapped (l->data, "notify::timezone",
-                                    G_CALLBACK(on_current_timezone_changed), self);
-        }
-
-      changed = TRUE;
-    }
-
-  if (changed)
-    on_current_timezone_changed (self);
-}
-
-/* When the 'auto-detect timezone' boolean setting changes,
-   start or stop watching geoclue and /etc/timezone */
-static void
-on_detect_location_changed (IndicatorDatetimeClockLive * self)
-{
-  const gboolean enabled = g_settings_get_boolean (self->priv->settings, SETTINGS_SHOW_DETECTED_S);
-  set_detect_location_enabled (self, enabled);
-}
-
-/***
-****  IndicatorDatetimeClock virtual functions
-***/
-
-static void
-rebuild_timezones (IndicatorDatetimeClockLive * self)
-{
-  priv_t * p;
-  GHashTable * hash;
-  GSList * l;
-  int i;
-  GHashTableIter iter;
-  gpointer key;
-
-  p = self->priv;
-
-  /* Build a hashtable of timezone strings.
-     This will weed out duplicates. */
-  hash = g_hash_table_new (g_str_hash, g_str_equal);
-  for (l=p->timezones; l!=NULL; l=l->next)
-    {
-      const gchar * tz = indicator_datetime_timezone_get_timezone (l->data);
-      if (tz && *tz)
-        g_hash_table_add (hash, (gpointer) tz);
-    }
-
-  /* rebuild p->timezone_strv */
-  g_strfreev (p->timezones_strv);
-  p->timezones_strv = g_new0 (gchar*, g_hash_table_size(hash) + 1);
-  i = 0;
-  g_hash_table_iter_init (&iter, hash);
-  while (g_hash_table_iter_next (&iter, &key, NULL))
-    p->timezones_strv[i++] = g_strdup (key);
-
-  /* rebuild localtime_zone */
-  g_clear_pointer (&p->localtime_zone, g_time_zone_unref);
-  p->localtime_zone = g_time_zone_new (p->timezones_strv ? p->timezones_strv[0] : NULL);
-
-  /* cleanup */
-  g_hash_table_unref (hash);
-}
-
-static const gchar **
-my_get_timezones (IndicatorDatetimeClock * clock)
-{
-  IndicatorDatetimeClockLive * self = INDICATOR_DATETIME_CLOCK_LIVE (clock);
-  priv_t * p = self->priv;
-
-  if (G_UNLIKELY (p->timezones_strv == NULL))
-    rebuild_timezones (self);
-
-  return (const gchar **) p->timezones_strv;
-}
-
-static GDateTime *
-my_get_localtime (IndicatorDatetimeClock * clock)
-{
-  IndicatorDatetimeClockLive * self = INDICATOR_DATETIME_CLOCK_LIVE (clock);
-  priv_t * p = self->priv;
-
-  if (G_UNLIKELY (p->localtime_zone == NULL))
-    rebuild_timezones (self);
-
-  return g_date_time_new_now (p->localtime_zone);
-}
-
-/***
-****  GObject virtual functions
-***/
-
-static void
-my_dispose (GObject * o)
-{
-  IndicatorDatetimeClockLive * self;
-  priv_t * p;
-
-  self = INDICATOR_DATETIME_CLOCK_LIVE(o);
-  p = self->priv;
-
-  if (p->settings != NULL)
-    {
-      g_signal_handlers_disconnect_by_data (p->settings, self);
-      g_clear_object (&p->settings);
-    }
-
-  set_detect_location_enabled (self, FALSE);
-
-  G_OBJECT_CLASS (indicator_datetime_clock_live_parent_class)->dispose (o);
-}
-
-static void
-my_finalize (GObject * o)
-{
-  IndicatorDatetimeClockLive * self;
-  priv_t * p;
-
-  self = INDICATOR_DATETIME_CLOCK_LIVE(o);
-  p = self->priv;
-
-  g_clear_pointer (&p->localtime_zone, g_time_zone_unref);
-  g_strfreev (p->timezones_strv);
-
-  G_OBJECT_CLASS (indicator_datetime_clock_live_parent_class)->dispose (o);
-}
-
-/***
-****  Instantiation
-***/
-
-static void
-indicator_datetime_clock_live_class_init (IndicatorDatetimeClockLiveClass * klass)
-{
-  GObjectClass * object_class = G_OBJECT_CLASS (klass);
-
-  object_class->dispose = my_dispose;
-  object_class->finalize = my_finalize;
-
-  g_type_class_add_private (klass,
-                            sizeof (IndicatorDatetimeClockLivePriv));
-}
-
-static void
-indicator_datetime_clock_interface_init (IndicatorDatetimeClockInterface * iface)
-{
-  iface->get_localtime = my_get_localtime;
-  iface->get_timezones = my_get_timezones;
-}
-
-static void
-indicator_datetime_clock_live_init (IndicatorDatetimeClockLive * self)
-{
-  IndicatorDatetimeClockLivePriv * p;
-
-  p = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                   INDICATOR_TYPE_DATETIME_CLOCK_LIVE,
-                                   IndicatorDatetimeClockLivePriv);
-  self->priv = p;
-
-  p->settings = g_settings_new (SETTINGS_INTERFACE);
-  g_signal_connect_swapped (p->settings, "changed::" SETTINGS_SHOW_DETECTED_S,
-                            G_CALLBACK(on_detect_location_changed), self);
-
-  on_detect_location_changed (self);
-}
-
-/***
-****  Public API
-***/
-
-IndicatorDatetimeClock *
-indicator_datetime_clock_live_new (void)
-{
-  gpointer o = g_object_new (INDICATOR_TYPE_DATETIME_CLOCK_LIVE, NULL);
-
-  return INDICATOR_DATETIME_CLOCK (o);
-}

=== added file 'src/clock-live.cpp'
--- src/clock-live.cpp	1970-01-01 00:00:00 +0000
+++ src/clock-live.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/clock.h>
+#include <datetime/timezones.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+namespace
+{
+
+void clearTimer(guint& tag)
+{
+    if (tag)
+    {
+        g_source_remove(tag);
+        tag = 0;
+    }
+}
+
+guint calculate_milliseconds_until_next_minute(const DateTime& now)
+{
+    auto next = g_date_time_add_minutes(now.get(), 1);
+    auto start_of_next = g_date_time_add_seconds (next, -g_date_time_get_seconds(next));
+    const auto interval_usec = g_date_time_difference(start_of_next, now.get());
+    const guint interval_msec = (interval_usec + 999) / 1000;
+    g_date_time_unref(start_of_next);
+    g_date_time_unref(next);
+    g_assert (interval_msec <= 60000);
+    return interval_msec;
+}
+
+} // unnamed namespace
+
+
+class LiveClock::Impl
+{
+public:
+
+    Impl(LiveClock& owner, const std::shared_ptr<const Timezones>& tzd):
+        m_owner(owner),
+        m_timezones(tzd)
+    {
+        if (m_timezones)
+        {
+            m_timezones->timezone.changed().connect([this](const std::string& z) {setTimezone(z);});
+            setTimezone(m_timezones->timezone.get());
+        }
+
+        restart_minute_timer();
+    }
+
+    ~Impl()
+    {
+        clearTimer(m_timer);
+
+        g_clear_pointer(&m_timezone, g_time_zone_unref);
+    }
+
+    DateTime localtime() const
+    {
+        g_assert(m_timezone != nullptr);
+
+        auto gdt = g_date_time_new_now(m_timezone);
+        DateTime ret(gdt);
+        g_date_time_unref(gdt);
+        return ret;
+    }
+
+private:
+
+    void setTimezone(const std::string& str)
+    {
+        g_clear_pointer(&m_timezone, g_time_zone_unref);
+        m_timezone = g_time_zone_new(str.c_str());
+        m_owner.minute_changed();
+    }
+
+    /***
+    ****
+    ***/
+
+    void restart_minute_timer()
+    {
+        clearTimer(m_timer);
+
+        // maybe emit change signals
+        const auto now = localtime();
+        if (!DateTime::is_same_minute(m_prev_datetime, now))
+            m_owner.minute_changed();
+        if (!DateTime::is_same_day(m_prev_datetime, now))
+            m_owner.date_changed();
+
+        // queue up a timer to fire at the next minute
+        m_prev_datetime = now;
+        auto interval_msec = calculate_milliseconds_until_next_minute(now);
+        interval_msec += 50; // add a small margin to ensure the callback
+                             // fires /after/ next is reached
+        m_timer = g_timeout_add_full(G_PRIORITY_HIGH,
+                                     interval_msec,
+                                     on_minute_timer_reached,
+                                     this,
+                                     nullptr);
+    }
+
+    static gboolean on_minute_timer_reached(gpointer gself)
+    {
+        static_cast<LiveClock::Impl*>(gself)->restart_minute_timer();
+        return G_SOURCE_REMOVE;
+    }
+
+protected:
+
+    LiveClock& m_owner;
+    GTimeZone* m_timezone = nullptr;
+    std::shared_ptr<const Timezones> m_timezones;
+
+    DateTime m_prev_datetime;
+    unsigned int m_timer = 0;
+};
+
+LiveClock::LiveClock(const std::shared_ptr<const Timezones>& tzd):
+    p(new Impl(*this, tzd))
+{
+}
+
+LiveClock::~LiveClock() =default;
+
+DateTime LiveClock::localtime() const
+{
+    return p->localtime();
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+

=== removed file 'src/clock-live.h'
--- src/clock-live.h	2013-10-17 21:32:44 +0000
+++ src/clock-live.h	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-/*
- * Copyright 2013 Canonical Ltd.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __INDICATOR_DATETIME_CLOCK_LIVE__H__
-#define __INDICATOR_DATETIME_CLOCK_LIVE__H__
-
-#include <glib-object.h> /* parent class */
-
-#include "clock.h"
-
-G_BEGIN_DECLS
-
-#define INDICATOR_TYPE_DATETIME_CLOCK_LIVE \
-  (indicator_datetime_clock_live_get_type())
-
-#define INDICATOR_DATETIME_CLOCK_LIVE(o) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((o), \
-                               INDICATOR_TYPE_DATETIME_CLOCK_LIVE, \
-                               IndicatorDatetimeClockLive))
-
-#define INDICATOR_DATETIME_CLOCK_LIVE_GET_CLASS(o) \
- (G_TYPE_INSTANCE_GET_CLASS ((o), \
-                             INDICATOR_TYPE_DATETIME_CLOCK_LIVE, \
-                             IndicatorDatetimeClockLiveClass))
-
-#define INDICATOR_IS_DATETIME_CLOCK_LIVE(o) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((o), \
-                               INDICATOR_TYPE_DATETIME_CLOCK_LIVE))
-
-typedef struct _IndicatorDatetimeClockLive
-                IndicatorDatetimeClockLive;
-typedef struct _IndicatorDatetimeClockLivePriv
-                IndicatorDatetimeClockLivePriv;
-typedef struct _IndicatorDatetimeClockLiveClass
-                IndicatorDatetimeClockLiveClass;
-
-/**
- * An IndicatorDatetimeClock which gives live clock times
- * from timezones determined by geoclue and /etc/timezone
- */
-struct _IndicatorDatetimeClockLive
-{
-  GObject parent_instance;
-
-  IndicatorDatetimeClockLivePriv * priv;
-};
-
-struct _IndicatorDatetimeClockLiveClass
-{
-  GObjectClass parent_class;
-};
-
-IndicatorDatetimeClock * indicator_datetime_clock_live_new (void);
-
-G_END_DECLS
-
-#endif /* __INDICATOR_DATETIME_CLOCK_LIVE__H__ */

=== removed file 'src/clock.c'
--- src/clock.c	2013-10-24 21:47:08 +0000
+++ src/clock.c	1970-01-01 00:00:00 +0000
@@ -1,110 +0,0 @@
-/*
- * Copyright 2013 Canonical Ltd.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "clock.h"
-
-enum
-{
-  SIGNAL_CHANGED,
-  SIGNAL_LAST
-};
-
-static guint signals[SIGNAL_LAST] = { 0 };
-
-G_DEFINE_INTERFACE (IndicatorDatetimeClock,
-                    indicator_datetime_clock,
-                    G_TYPE_OBJECT);
-
-static void
-indicator_datetime_clock_default_init (IndicatorDatetimeClockInterface * klass)
-{
-  signals[SIGNAL_CHANGED] = g_signal_new (
-      "changed",
-      G_TYPE_FROM_CLASS(klass),
-      G_SIGNAL_RUN_LAST,
-      G_STRUCT_OFFSET (IndicatorDatetimeClockInterface, changed),
-      NULL, NULL,
-      g_cclosure_marshal_VOID__VOID,
-      G_TYPE_NONE, 0);
-}
-
-/***
-****  PUBLIC API
-***/
-
-/**
- * Get a strv of timezones.
- *
- * Return value: (element-type char*)
- *               (transfer full):
- *               array of timezone strings
- */
-const gchar **
-indicator_datetime_clock_get_timezones (IndicatorDatetimeClock * self)
-{
-  const gchar ** timezones;
-  IndicatorDatetimeClockInterface * iface;
-
-  g_return_val_if_fail (INDICATOR_IS_DATETIME_CLOCK(self), NULL);
-  iface = INDICATOR_DATETIME_CLOCK_GET_INTERFACE(self);
-
-  if (iface->get_timezones != NULL)
-    timezones = iface->get_timezones (self);
-  else
-    timezones = NULL;
-
-  return timezones;
-}
-
-/**
- * Get the current time.
- *
- * Return value: (element-type GDateTime*)
- *               (transfer full):
- *               the current time.
- */
-GDateTime *
-indicator_datetime_clock_get_localtime (IndicatorDatetimeClock * self)
-{
-  GDateTime * now;
-  IndicatorDatetimeClockInterface * iface;
-
-  g_return_val_if_fail (INDICATOR_IS_DATETIME_CLOCK(self), NULL);
-  iface = INDICATOR_DATETIME_CLOCK_GET_INTERFACE(self);
-
-  if (iface->get_localtime != NULL)
-    now = iface->get_localtime (self);
-  else
-    now = NULL;
-
-  return now;
-}
-
-/**
- * Emits the "changed" signal.
- *
- * This should only be called by subclasses.
- */
-void
-indicator_datetime_clock_emit_changed (IndicatorDatetimeClock * self)
-{
-  g_return_if_fail (INDICATOR_IS_DATETIME_CLOCK (self));
-
-  g_signal_emit (self, signals[SIGNAL_CHANGED], 0, NULL);
-}

=== added file 'src/clock.cpp'
--- src/clock.cpp	1970-01-01 00:00:00 +0000
+++ src/clock.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/clock.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+Clock::Clock():
+    m_cancellable(g_cancellable_new())
+{
+    g_bus_get(G_BUS_TYPE_SYSTEM, m_cancellable, on_system_bus_ready, this);
+}
+
+Clock::~Clock()
+{
+    g_cancellable_cancel(m_cancellable);
+    g_clear_object(&m_cancellable);
+
+    if (m_sleep_subscription_id)
+        g_dbus_connection_signal_unsubscribe(m_system_bus, m_sleep_subscription_id);
+
+    g_clear_object(&m_system_bus);
+}
+
+void
+Clock::on_system_bus_ready(GObject*, GAsyncResult * res, gpointer gself)
+{
+    GDBusConnection * system_bus;
+
+    if ((system_bus = g_bus_get_finish(res, nullptr)))
+    {
+        auto self = static_cast<Clock*>(gself);
+
+        self->m_system_bus = system_bus;
+
+        self->m_sleep_subscription_id = g_dbus_connection_signal_subscribe(
+                        system_bus,
+                        nullptr,
+                        "org.freedesktop.login1.Manager", // interface
+                        "PrepareForSleep", // signal name
+                        "/org/freedesktop/login1", // object path
+                        nullptr, // arg0
+                        G_DBUS_SIGNAL_FLAGS_NONE,
+                        on_prepare_for_sleep,
+                        self,
+                        nullptr);
+    }
+}
+
+void
+Clock::on_prepare_for_sleep(GDBusConnection* /*connection*/,
+                            const gchar*     /*sender_name*/,
+                            const gchar*     /*object_path*/,
+                            const gchar*     /*interface_name*/,
+                            const gchar*     /*signal_name*/,
+                            GVariant*        /*parameters*/,
+                            gpointer           gself)
+{
+    static_cast<Clock*>(gself)->minute_changed();
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== removed file 'src/clock.h'
--- src/clock.h	2013-10-17 23:15:33 +0000
+++ src/clock.h	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-/*
- * Copyright 2013 Canonical Ltd.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __INDICATOR_DATETIME_CLOCK__H__
-#define __INDICATOR_DATETIME_CLOCK__H__
-
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-#define INDICATOR_TYPE_DATETIME_CLOCK \
-  (indicator_datetime_clock_get_type ())
-
-#define INDICATOR_DATETIME_CLOCK(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-                               INDICATOR_TYPE_DATETIME_CLOCK, \
-                               IndicatorDatetimeClock))
-
-#define INDICATOR_IS_DATETIME_CLOCK(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_TYPE_DATETIME_CLOCK))
-
-#define INDICATOR_DATETIME_CLOCK_GET_INTERFACE(inst) \
-  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), \
-                                  INDICATOR_TYPE_DATETIME_CLOCK, \
-                                  IndicatorDatetimeClockInterface))
-
-typedef struct _IndicatorDatetimeClock
-                IndicatorDatetimeClock;
-
-typedef struct _IndicatorDatetimeClockInterface
-                IndicatorDatetimeClockInterface;
-
-struct _IndicatorDatetimeClockInterface
-{
-  GTypeInterface parent_iface;
-
-  /* signals */
-  void (*changed) (IndicatorDatetimeClock * self);
-
-  /* virtual functions */
-  const gchar** (*get_timezones) (IndicatorDatetimeClock * self);
-  GDateTime* (*get_localtime) (IndicatorDatetimeClock * self);
-};
-
-GType indicator_datetime_clock_get_type (void);
-
-/***
-****
-***/
-
-const gchar ** indicator_datetime_clock_get_timezones    (IndicatorDatetimeClock * clock);
-
-GDateTime    * indicator_datetime_clock_get_localtime    (IndicatorDatetimeClock * clock);
-
-void           indicator_datetime_clock_emit_changed     (IndicatorDatetimeClock * clock);
-
-
-G_END_DECLS
-
-#endif /* __INDICATOR_DATETIME_CLOCK__H__ */

=== added file 'src/date-time.cpp'
--- src/date-time.cpp	1970-01-01 00:00:00 +0000
+++ src/date-time.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/date-time.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+DateTime::DateTime(GDateTime* gdt)
+{
+    reset(gdt);
+}
+
+DateTime& DateTime::operator=(GDateTime* gdt)
+{
+    reset(gdt);
+    return *this;
+}
+
+DateTime& DateTime::operator=(const DateTime& that)
+{
+    m_dt = that.m_dt;
+    return *this;
+}
+
+DateTime::DateTime(time_t t)
+{
+    GDateTime * gdt = g_date_time_new_from_unix_local(t);
+    reset(gdt);
+    g_date_time_unref(gdt);
+}
+
+DateTime DateTime::NowLocal()
+{
+    GDateTime * gdt = g_date_time_new_now_local();
+    DateTime dt(gdt);
+    g_date_time_unref(gdt);
+    return dt;
+}
+
+DateTime DateTime::to_timezone(const std::string& zone) const
+{
+    auto gtz = g_time_zone_new(zone.c_str());
+    auto gdt = g_date_time_to_timezone(get(), gtz);
+    DateTime dt(gdt);
+    g_time_zone_unref(gtz);
+    g_date_time_unref(gdt);
+    return dt;
+}
+
+GDateTime* DateTime::get() const
+{
+    g_assert(m_dt);
+    return m_dt.get();
+}
+
+std::string DateTime::format(const std::string& fmt) const
+{
+    const auto str = g_date_time_format(get(), fmt.c_str());
+    std::string ret = str;
+    g_free(str);
+    return ret;
+}
+
+int DateTime::day_of_month() const
+{
+    return g_date_time_get_day_of_month(get());
+}
+
+int64_t DateTime::to_unix() const
+{
+    return g_date_time_to_unix(get());
+}
+
+void DateTime::reset(GDateTime* in)
+{
+    if (in)
+    {
+        auto deleter = [](GDateTime* dt){g_date_time_unref(dt);};
+        m_dt = std::shared_ptr<GDateTime>(g_date_time_ref(in), deleter);
+        g_assert(m_dt);
+    }
+    else
+    {
+        m_dt.reset();
+    }
+}
+
+bool DateTime::operator<(const DateTime& that) const
+{
+    return g_date_time_compare(get(), that.get()) < 0;
+}
+
+bool DateTime::operator!=(const DateTime& that) const
+{
+    // return true if this isn't set, or if it's not equal
+    return (!m_dt) || !(*this == that);
+}
+
+bool DateTime::operator==(const DateTime& that) const
+{
+    auto dt = get();
+    auto tdt = that.get();
+    if (!dt && !tdt) return true;
+    if (!dt || !tdt) return false;
+    return g_date_time_compare(get(), that.get()) == 0;
+}
+
+bool DateTime::is_same_day(const DateTime& a, const DateTime& b)
+{
+    // it's meaningless to compare uninitialized dates
+    if (!a.m_dt || !b.m_dt)
+        return false;
+
+    const auto adt = a.get();
+    const auto bdt = b.get();
+    return (g_date_time_get_year(adt) == g_date_time_get_year(bdt))
+        && (g_date_time_get_day_of_year(adt) == g_date_time_get_day_of_year(bdt));
+}
+
+bool DateTime::is_same_minute(const DateTime& a, const DateTime& b)
+{
+    if (!is_same_day(a,b))
+        return false;
+
+    const auto adt = a.get();
+    const auto bdt = b.get();
+    return (g_date_time_get_hour(adt) == g_date_time_get_hour(bdt))
+        && (g_date_time_get_minute(adt) == g_date_time_get_minute(bdt));
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== removed file 'src/dbus-shared.h'
--- src/dbus-shared.h	2013-06-19 06:26:32 +0000
+++ src/dbus-shared.h	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-/*
-An indicator to show date and time information.
-
-Copyright 2010 Canonical Ltd.
-
-Authors:
-    Ted Gould <[e-mail]>
-
-This program is free software: you can redistribute it and/or modify it 
-under the terms of the GNU General Public License version 3, as published 
-by the Free Software Foundation.
-
-This program is distributed in the hope that it will be useful, but 
-WITHOUT ANY WARRANTY; without even the implied warranties of 
-MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
-PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along 
-with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#define BUS_NAME "com.canonical.indicator.datetime"
-#define BUS_PATH "/com/canonical/indicator/datetime"
-

=== added file 'src/exporter.cpp'
--- src/exporter.cpp	1970-01-01 00:00:00 +0000
+++ src/exporter.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/dbus-shared.h>
+#include <datetime/exporter.h>
+
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+Exporter::~Exporter()
+{
+    if (m_dbus_connection != nullptr)
+    {
+        for(auto& id : m_exported_menu_ids)
+            g_dbus_connection_unexport_menu_model(m_dbus_connection, id);
+
+        if (m_exported_actions_id)
+            g_dbus_connection_unexport_action_group(m_dbus_connection, m_exported_actions_id);
+    }
+
+    if (m_own_id)
+        g_bus_unown_name(m_own_id);
+
+    g_clear_object(&m_dbus_connection);
+}
+
+/***
+****
+***/
+
+void
+Exporter::on_bus_acquired(GDBusConnection* connection, const gchar* name, gpointer gthis)
+{
+    g_debug("bus acquired: %s", name);
+    static_cast<Exporter*>(gthis)->on_bus_acquired(connection, name);
+}
+
+void
+Exporter::on_bus_acquired(GDBusConnection* connection, const gchar* /*name*/)
+{
+    m_dbus_connection = static_cast<GDBusConnection*>(g_object_ref(G_OBJECT(connection)));
+
+    // export the actions
+    GError * error = nullptr;
+    const auto id = g_dbus_connection_export_action_group(m_dbus_connection,
+                                                          BUS_PATH,
+                                                          m_actions->action_group(),
+                                                          &error);
+    if (id)
+    {
+        m_exported_actions_id = id;
+    }
+    else
+    {
+        g_warning("cannot export action group: %s", error->message);
+        g_clear_error(&error);
+    }
+
+    // export the menus
+    for(auto& menu : m_menus)
+    {
+        const auto path = std::string(BUS_PATH) + "/" + menu->name();
+        const auto id = g_dbus_connection_export_menu_model(m_dbus_connection, path.c_str(), menu->menu_model(), &error);
+        if (id)
+        {
+            m_exported_menu_ids.insert(id);
+        }
+        else
+        {
+            if (error != nullptr)
+                g_warning("cannot export %s menu: %s", menu->name().c_str(), error->message);
+            g_clear_error(&error);
+        }
+    }
+}
+
+/***
+****
+***/
+
+void
+Exporter::on_name_lost(GDBusConnection* connection, const gchar* name, gpointer gthis)
+{
+    g_debug("name lost: %s", name);
+    static_cast<Exporter*>(gthis)->on_name_lost(connection, name);
+}
+
+void
+Exporter::on_name_lost(GDBusConnection* /*connection*/, const gchar* /*name*/)
+{
+    name_lost();
+}
+
+/***
+****
+***/
+
+void
+Exporter::publish(const std::shared_ptr<Actions>& actions,
+                  const std::vector<std::shared_ptr<Menu>>& menus)
+{
+    m_actions = actions;
+    m_menus = menus;
+    m_own_id = g_bus_own_name(G_BUS_TYPE_SESSION,
+                              BUS_NAME,
+                              G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT,
+                              on_bus_acquired,
+                              nullptr,
+                              on_name_lost,
+                              this,
+                              nullptr);
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+

=== added file 'src/formatter-desktop.cpp'
--- src/formatter-desktop.cpp	1970-01-01 00:00:00 +0000
+++ src/formatter-desktop.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/formatter.h>
+#include <datetime/utils.h> // T_()
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+namespace
+{
+
+std::string joinDateAndTimeFormatStrings(const char* date_string,
+                                         const char* time_string)
+{
+    std::string str;
+
+    if (date_string && time_string)
+    {
+        /* TRANSLATORS: This is a format string passed to strftime to
+         * combine the date and the time.  The value of "%s\u2003%s"
+         * will result in a string like this in US English 12-hour time:
+         * 'Fri Jul 16 11:50 AM'. The space in between date and time is
+         * a Unicode en space (E28082 in UTF-8 hex). */
+        str = date_string;
+        str += "\u2003";
+        str += time_string;
+    }
+    else if (date_string)
+    {
+        str = date_string;
+    }
+    else // time_string
+    {
+        str = time_string;
+    }
+
+    return str;
+}
+} // unnamed namespace
+
+/***
+****
+***/
+
+DesktopFormatter::DesktopFormatter(const std::shared_ptr<const Clock>&    clock_in,
+                                   const std::shared_ptr<const Settings>& settings_in):
+    Formatter(clock_in),
+    m_settings(settings_in)
+{
+    m_settings->show_day.changed().connect([this](bool){rebuildHeaderFormat();});
+    m_settings->show_date.changed().connect([this](bool){rebuildHeaderFormat();});
+    m_settings->show_year.changed().connect([this](bool){rebuildHeaderFormat();});
+    m_settings->show_seconds.changed().connect([this](bool){rebuildHeaderFormat();});
+    m_settings->time_format_mode.changed().connect([this](TimeFormatMode){rebuildHeaderFormat();});
+    m_settings->custom_time_format.changed().connect([this](const std::string&){rebuildHeaderFormat();});
+
+    rebuildHeaderFormat();
+}
+
+void DesktopFormatter::rebuildHeaderFormat()
+{
+    header_format.set(getHeaderLabelFormatString());
+}
+
+std::string DesktopFormatter::getHeaderLabelFormatString() const
+{
+    std::string fmt;
+    const auto mode = m_settings->time_format_mode.get();
+
+    if (mode == TIME_FORMAT_MODE_CUSTOM)
+    {
+        fmt = m_settings->custom_time_format.get();
+    }
+    else
+    {
+        const auto show_day = m_settings->show_day.get();
+        const auto show_date = m_settings->show_date.get();
+        const auto show_year = show_date && m_settings->show_year.get();
+        const auto date_fmt = getDateFormat(show_day, show_date, show_year);
+        const auto time_fmt = getFullTimeFormatString();
+        fmt = joinDateAndTimeFormatStrings(date_fmt, time_fmt);
+    }
+
+    return fmt;
+}
+
+const gchar* DesktopFormatter::getFullTimeFormatString() const
+{
+    const auto show_seconds = m_settings->show_seconds.get();
+
+    bool twelvehour;
+    switch (m_settings->time_format_mode.get())
+    {
+    case TIME_FORMAT_MODE_LOCALE_DEFAULT:
+        twelvehour = is_locale_12h();
+        break;
+
+    case TIME_FORMAT_MODE_24_HOUR:
+        twelvehour = false;
+        break;
+
+    default:
+        twelvehour = true;
+        break;
+    }
+
+    return default_header_time_format(twelvehour, show_seconds);
+}
+
+const gchar* DesktopFormatter::getDateFormat(bool show_day, bool show_date, bool show_year) const
+{
+    const char * fmt;
+
+    if (show_day && show_date && show_year)
+        /* TRANSLATORS: a strftime(3) format showing the weekday, date, and year */
+        fmt = T_("%a %b %e %Y");
+    else if (show_day && show_date)
+        /* TRANSLATORS: a strftime(3) format showing the weekday and date */
+        fmt = T_("%a %b %e");
+    else if (show_day && show_year)
+        /* TRANSLATORS: a strftime(3) format showing the weekday and year. */
+        fmt = T_("%a %Y");
+    else if (show_day)
+        /* TRANSLATORS: a strftime(3) format showing the weekday. */
+        fmt = T_("%a");
+    else if (show_date && show_year)
+        /* TRANSLATORS: a strftime(3) format showing the date and year */
+        fmt = T_("%b %e %Y");
+    else if (show_date)
+        /* TRANSLATORS: a strftime(3) format showing the date */
+        fmt = T_("%b %e");
+    else if (show_year)
+        /* TRANSLATORS: a strftime(3) format showing the year */
+        fmt = T_("%Y");
+    else
+        fmt = nullptr;
+
+    return fmt;
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== added file 'src/formatter.cpp'
--- src/formatter.cpp	1970-01-01 00:00:00 +0000
+++ src/formatter.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/formatter.h>
+
+#include <datetime/clock.h>
+#include <datetime/utils.h> // T_()
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <locale.h> // setlocale()
+#include <langinfo.h> // nl_langinfo()
+#include <string.h> // strstr()
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+namespace
+{
+
+void clear_timer(guint& tag)
+{
+    if (tag)
+    {
+        g_source_remove(tag);
+        tag = 0;
+    }
+}
+
+gint calculate_milliseconds_until_next_second(const DateTime& now)
+{
+    gint interval_usec;
+    guint interval_msec;
+
+    interval_usec = G_USEC_PER_SEC - g_date_time_get_microsecond(now.get());
+    interval_msec = (interval_usec + 999) / 1000;
+    return interval_msec;
+}
+
+/*
+ * We periodically rebuild the sections that have time format strings
+ * that are dependent on the current time:
+ *
+ * 1. appointment menuitems' time format strings depend on the
+ *    current time; for example, they don't show the day of week
+ *    if the appointment is today.
+ *
+ * 2. location menuitems' time format strings depend on the
+ *    current time; for example, they don't show the day of the week
+ *    if the local date and location date are the same.
+ *
+ * 3. the "local date" menuitem in the calendar section is,
+ *    obviously, dependent on the local time.
+ *
+ * In short, we want to update whenever the number of days between two zone
+ * might have changed. We do that by updating when either zone's day changes.
+ *
+ * Since not all UTC offsets are evenly divisible by hours
+ * (examples: Newfoundland UTC-03:30, Nepal UTC+05:45), refreshing on the hour
+ * is not enough. We need to refresh at HH:00, HH:15, HH:30, and HH:45.
+ */
+guint calculate_seconds_until_next_fifteen_minutes(GDateTime * now)
+{
+    char * str;
+    gint minute;
+    guint seconds;
+    GTimeSpan diff;
+    GDateTime * next;
+    GDateTime * start_of_next;
+
+    minute = g_date_time_get_minute(now);
+    minute = 15 - (minute % 15);
+    next = g_date_time_add_minutes(now, minute);
+    start_of_next = g_date_time_new_local(g_date_time_get_year(next),
+                                          g_date_time_get_month(next),
+                                          g_date_time_get_day_of_month(next),
+                                          g_date_time_get_hour(next),
+                                          g_date_time_get_minute(next),
+                                          0.1);
+
+    str = g_date_time_format(start_of_next, "%F %T");
+    g_debug("%s %s the next timestamp rebuild will be at %s", G_STRLOC, G_STRFUNC, str);
+    g_free(str);
+
+    diff = g_date_time_difference(start_of_next, now);
+    seconds = (diff + (G_TIME_SPAN_SECOND-1)) / G_TIME_SPAN_SECOND;
+
+    g_date_time_unref(start_of_next);
+    g_date_time_unref(next);
+    return seconds;
+}
+} // unnamed namespace
+
+
+class Formatter::Impl
+{
+public:
+
+    Impl(Formatter* owner, const std::shared_ptr<const Clock>& clock):
+        m_owner(owner),
+        m_clock(clock)
+    {
+        m_owner->header_format.changed().connect([this](const std::string& /*fmt*/){update_header();});
+        m_clock->minute_changed.connect([this](){update_header();});
+        update_header();
+
+        restartRelativeTimer();
+    }
+
+    ~Impl()
+    {
+        clear_timer(m_header_seconds_timer);
+        clear_timer(m_relative_timer);
+    }
+
+private:
+
+    static bool format_shows_seconds(const std::string& fmt)
+    {
+        return (fmt.find("%s") != std::string::npos)
+            || (fmt.find("%S") != std::string::npos)
+            || (fmt.find("%T") != std::string::npos)
+            || (fmt.find("%X") != std::string::npos)
+            || (fmt.find("%c") != std::string::npos);
+    }
+
+    void update_header()
+    {
+        // update the header property
+        const auto fmt = m_owner->header_format.get();
+        const auto str = m_clock->localtime().format(fmt);
+        m_owner->header.set(str);
+
+        // if the header needs to show seconds, set a timer.
+        if (format_shows_seconds(fmt))
+            start_header_timer();
+        else
+            clear_timer(m_header_seconds_timer);
+    }
+
+    // we've got a header format that shows seconds,
+    // so we need to update it every second
+    void start_header_timer()
+    {
+        clear_timer(m_header_seconds_timer);
+
+        const auto now = m_clock->localtime();
+        auto interval_msec = calculate_milliseconds_until_next_second(now);
+        interval_msec += 50; // add a small margin to ensure the callback
+                             // fires /after/ next is reached
+        m_header_seconds_timer = g_timeout_add_full(G_PRIORITY_HIGH,
+                                                    interval_msec,
+                                                    on_header_timer,
+                                                    this,
+                                                    nullptr);
+    }
+
+    static gboolean on_header_timer(gpointer gself)
+    {
+        static_cast<Formatter::Impl*>(gself)->update_header();
+        return G_SOURCE_REMOVE;
+    }
+
+private:
+
+    void restartRelativeTimer()
+    {
+        clear_timer(m_relative_timer);
+
+        const auto now = m_clock->localtime();
+        const auto seconds = calculate_seconds_until_next_fifteen_minutes(now.get());
+        m_relative_timer = g_timeout_add_seconds(seconds, onRelativeTimer, this);
+    }
+
+    static gboolean onRelativeTimer(gpointer gself)
+    {
+        auto self = static_cast<Formatter::Impl*>(gself);
+        self->m_owner->relative_format_changed();
+        self->restartRelativeTimer();
+        return G_SOURCE_REMOVE;
+    }
+
+private:
+    Formatter* const m_owner;
+    guint m_header_seconds_timer = 0;
+    guint m_relative_timer = 0;
+
+public:
+    std::shared_ptr<const Clock> m_clock;
+};
+
+/***
+****
+***/
+
+Formatter::Formatter(const std::shared_ptr<const Clock>& clock):
+    p(new Formatter::Impl(this, clock))
+{
+}
+
+Formatter::~Formatter()
+{
+}
+
+const char*
+Formatter::default_header_time_format(bool twelvehour, bool show_seconds)
+{
+  const char* fmt;
+
+  if (twelvehour && show_seconds)
+    /* TRANSLATORS: a strftime(3) format for 12hr time w/seconds */
+    fmt = T_("%l:%M:%S %p");
+  else if (twelvehour)
+    /* TRANSLATORS: a strftime(3) format for 12hr time */
+    fmt = T_("%l:%M %p");
+  else if (show_seconds)
+    /* TRANSLATORS: a strftime(3) format for 24hr time w/seconds */
+    fmt = T_("%H:%M:%S");
+  else
+    /* TRANSLATORS: a strftime(3) format for 24hr time */
+    fmt = T_("%H:%M");
+
+  return fmt;
+}
+
+/***
+****
+***/
+
+std::string
+Formatter::relative_format(GDateTime* then_begin, GDateTime* then_end) const
+{
+    auto cstr = generate_full_format_string_at_time (p->m_clock->localtime().get(), then_begin, then_end);
+    const std::string ret = cstr;
+    g_free (cstr);
+    return ret;
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== added file 'src/locations-settings.cpp'
--- src/locations-settings.cpp	1970-01-01 00:00:00 +0000
+++ src/locations-settings.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/locations-settings.h>
+
+#include <datetime/settings-shared.h>
+#include <datetime/timezones.h>
+#include <datetime/utils.h>
+
+#include <algorithm> // std::find()
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+SettingsLocations::SettingsLocations(const std::shared_ptr<const Settings>& settings,
+                                     const std::shared_ptr<const Timezones>& timezones):
+    m_settings(settings),
+    m_timezones(timezones)
+{
+    m_settings->locations.changed().connect([this](const std::vector<std::string>&){reload();});
+    m_settings->show_locations.changed().connect([this](bool){reload();});
+    m_timezones->timezone.changed().connect([this](const std::string&){reload();});
+    m_timezones->timezones.changed().connect([this](const std::set<std::string>&){reload();});
+
+    reload();
+}
+
+void
+SettingsLocations::reload()
+{
+    std::vector<Location> v;
+    const std::string timezone_name = m_settings->timezone_name.get();
+
+    // add the primary timezone first
+    auto zone = m_timezones->timezone.get();
+    if (!zone.empty())
+    {
+        gchar * name = get_beautified_timezone_name(zone.c_str(), timezone_name.c_str());
+        Location l(zone, name);
+        v.push_back(l);
+        g_free(name);
+    }
+
+    // add the other detected timezones
+    for(const auto& zone : m_timezones->timezones.get())
+    {
+        gchar * name = get_beautified_timezone_name(zone.c_str(), timezone_name.c_str());
+        Location l(zone, name);
+        if (std::find(v.begin(), v.end(), l) == v.end())
+            v.push_back(l);
+        g_free(name);
+    }
+
+    // maybe add the user-specified locations
+    if (m_settings->show_locations.get())
+    {
+        for(const auto& locstr : m_settings->locations.get())
+        {
+            gchar* zone;
+            gchar* name;
+            split_settings_location(locstr.c_str(), &zone, &name);
+            Location loc(zone, name);
+            if (std::find(v.begin(), v.end(), loc) == v.end())
+                v.push_back(loc);
+            g_free(name);
+            g_free(zone);
+        }
+    }
+
+    locations.set(v);
+}
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== added file 'src/locations.cpp'
--- src/locations.cpp	1970-01-01 00:00:00 +0000
+++ src/locations.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/locations.h>
+
+#include <glib.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+const std::string& Location::zone() const
+{
+    return m_zone;
+}
+
+const std::string& Location::name() const
+{
+    return m_name;
+}
+
+bool Location::operator== (const Location& that) const
+{
+    return (m_name == that.m_name)
+        && (m_zone == that.m_zone)
+        && (m_offset == that.m_offset);
+}
+
+
+Location::Location(const std::string& zone_, const std::string& name_):
+    m_zone(zone_),
+    m_name(name_)
+{
+    auto gzone = g_time_zone_new (zone().c_str());
+    auto gtime = g_date_time_new_now (gzone);
+    m_offset = g_date_time_get_utc_offset (gtime);
+    g_date_time_unref (gtime);
+    g_time_zone_unref (gzone);
+}
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity

=== removed file 'src/main.c'
--- src/main.c	2013-10-30 23:49:58 +0000
+++ src/main.c	1970-01-01 00:00:00 +0000
@@ -1,83 +0,0 @@
-/*
- * Copyright 2013 Canonical Ltd.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <locale.h>
-#include <stdlib.h> /* exit() */
-
-#include <glib/gi18n.h>
-#include <gio/gio.h>
-#include <libnotify/notify.h> 
-
-#include "clock-live.h"
-#include "planner-eds.h"
-#include "service.h"
-
-/***
-****
-***/
-
-static void
-on_name_lost (gpointer instance G_GNUC_UNUSED, gpointer loop)
-{
-  g_message ("exiting: service couldn't acquire or lost ownership of busname");
-
-  g_main_loop_quit ((GMainLoop*)loop);
-}
-
-int
-main (int argc G_GNUC_UNUSED, char ** argv G_GNUC_UNUSED)
-{
-  IndicatorDatetimeClock * clock;
-  IndicatorDatetimePlanner * planner;
-  IndicatorDatetimeService * service;
-  GMainLoop * loop;
-
-  /* Work around a deadlock in glib's type initialization. It can be
-   * removed when https://bugzilla.gnome.org/show_bug.cgi?id=674885 is
-   * fixed.
-   */
-  g_type_ensure (G_TYPE_DBUS_CONNECTION);
-
-  /* boilerplate i18n */
-  setlocale (LC_ALL, "");
-  bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
-  textdomain (GETTEXT_PACKAGE);
-
-  /* init libnotify */
-  if (!notify_init ("indicator-datetime-service"))
-    g_critical ("libnotify initialization failed");
-
-  /* create the service */
-  clock = indicator_datetime_clock_live_new ();
-  planner = indicator_datetime_planner_eds_new ();
-  service = indicator_datetime_service_new (clock, planner);
-
-  /* run */
-  loop = g_main_loop_new (NULL, FALSE);
-  g_signal_connect (service, INDICATOR_DATETIME_SERVICE_SIGNAL_NAME_LOST,
-                    G_CALLBACK(on_name_lost), loop);
-  g_main_loop_run (loop);
-  g_main_loop_unref (loop);
-
-  /* cleanup */
-  g_object_unref (service);
-  g_object_unref (planner);
-  g_object_unref (clock);
-  return 0;
-}

=== added file 'src/main.cpp'
--- src/main.cpp	1970-01-01 00:00:00 +0000
+++ src/main.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+
+#include <datetime/actions-live.h>
+#include <datetime/clock.h>
+#include <datetime/exporter.h>
+#include <datetime/locations-settings.h>
+#include <datetime/menu.h>
+#include <datetime/planner-eds.h>
+#include <datetime/settings-live.h>
+#include <datetime/state.h>
+#include <datetime/timezones-live.h>
+
+#include <glib/gi18n.h> // bindtextdomain()
+#include <gio/gio.h>
+#include <libnotify/notify.h> 
+
+#include <locale.h>
+#include <stdlib.h> // exit()
+
+using namespace unity::indicator::datetime;
+
+int
+main(int /*argc*/, char** /*argv*/)
+{
+    // Work around a deadlock in glib's type initialization.
+    // It can be removed when https://bugzilla.gnome.org/show_bug.cgi?id=674885 is fixed.
+    g_type_ensure(G_TYPE_DBUS_CONNECTION);
+
+    // boilerplate i18n
+    setlocale(LC_ALL, "");
+    bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR);
+    textdomain(GETTEXT_PACKAGE);
+
+    // init libnotify
+    if(!notify_init("indicator-datetime-service"))
+        g_critical("libnotify initialization failed");
+
+    // build the state, actions, and menufactory
+    std::shared_ptr<State> state(new State);
+    std::shared_ptr<Settings> live_settings(new LiveSettings);
+    std::shared_ptr<Timezones> live_timezones(new LiveTimezones(live_settings, TIMEZONE_FILE));
+    std::shared_ptr<Clock> live_clock(new LiveClock(live_timezones));
+    state->settings = live_settings;
+    state->clock = live_clock;
+    state->locations.reset(new SettingsLocations(live_settings, live_timezones));
+    state->planner.reset(new PlannerEds);
+    state->planner->time = live_clock->localtime();
+    std::shared_ptr<Actions> actions(new LiveActions(state));
+    MenuFactory factory(actions, state);
+
+    // create the menus
+    std::vector<std::shared_ptr<Menu>> menus;
+    for(int i=0, n=Menu::NUM_PROFILES; i<n; i++)
+        menus.push_back(factory.buildMenu(Menu::Profile(i)));
+
+    // export them & run until we lose the busname
+    auto loop = g_main_loop_new(nullptr, false);
+    Exporter exporter;
+    exporter.name_lost.connect([loop](){
+        g_message("%s exiting; failed/lost bus ownership", GETTEXT_PACKAGE);
+        g_main_loop_quit(loop);
+    });
+    exporter.publish(actions, menus);
+    g_main_loop_run(loop);
+    g_main_loop_unref(loop);
+    return 0;
+}

=== added file 'src/menu.cpp'
--- src/menu.cpp	1970-01-01 00:00:00 +0000
+++ src/menu.cpp	2014-01-31 00:43:10 +0000
@@ -0,0 +1,598 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <datetime/menu.h>
+
+#include <datetime/formatter.h>
+#include <datetime/state.h>
+
+#include <json-glib/json-glib.h>
+
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/****
+*****
+****/
+
+Menu::Menu (Profile profile_in, const std::string& name_in):
+    m_profile(profile_in),
+    m_name(name_in)
+{
+}
+
+const std::string& Menu::name() const
+{
+    return m_name;
+}
+
+Menu::Profile Menu::profile() const
+{
+    return m_profile;
+}
+
+GMenuModel* Menu::menu_model()
+{
+    return G_MENU_MODEL(m_menu);
+}
+
+
+/****
+*****
+****/
+
+
+#define FALLBACK_ALARM_CLOCK_ICON_NAME "clock"
+#define CALENDAR_ICON_NAME "calendar"
+
+class MenuImpl: public Menu
+{
+protected:
+    MenuImpl(const Menu::Profile profile_in,
+             const std::string& name_in,
+             std::shared_ptr<const State>& state,
+             std::shared_ptr<Actions>& actions,
+             std::shared_ptr<const Formatter> formatter):
+        Menu(profile_in, name_in),
+        m_state(state),
+        m_actions(actions),
+        m_formatter(formatter)
+    {
+        // preload the alarm icon from click
+        m_serialized_alarm_icon = create_alarm_icon();
+
+        // initialize the menu
+        create_gmenu();
+        for (int i=0; i<NUM_SECTIONS; i++)
+            update_section(Section(i));
+
+        // listen for state changes so we can update the menu accordingly
+        m_formatter->header.changed().connect([this](const std::string&){
+            update_header();
+        });
+        m_formatter->header_format.changed().connect([this](const std::string&){
+            update_section(Locations); // need to update x-canonical-time-format
+        });
+        m_formatter->relative_format_changed.connect([this](){
+            update_section(Appointments); // uses formatter.relative_format()
+            update_section(Locations); // uses formatter.relative_format()
+        });
+        m_state->settings->show_clock.changed().connect([this](bool){
+            update_header(); // update header's label
+            update_section(Locations); // locations' relative time may have changed
+        });
+        m_state->settings->show_calendar.changed().connect([this](bool){
+            update_section(Calendar);
+        });
+        m_state->settings->show_events.changed().connect([this](bool){
+            update_section(Appointments); // showing events got toggled
+        });
+        m_state->planner->upcoming.changed().connect([this](const std::vector<Appointment>&){
+            update_section(Appointments); // "upcoming" is the list of Appointments we show
+        });
+        m_state->clock->date_changed.connect([this](){
+            update_section(Calendar); // need to update the Date menuitem
+            update_section(Locations); // locations' relative time may have changed
+        });
+        m_state->locations->locations.changed().connect([this](const std::vector<Location>&) {
+            update_section(Locations); // "locations" is the list of Locations we show
+        });
+    }
+
+    virtual ~MenuImpl()
+    {
+        g_clear_object(&m_menu);
+        g_clear_pointer(&m_serialized_alarm_icon, g_variant_unref);
+        g_clear_pointer(&m_serialized_calendar_icon, g_variant_unref);
+    }
+
+    virtual GVariant* create_header_state() =0;
+
+    void update_header()
+    {
+        auto action_group = m_actions->action_group();
+        auto action_name = name() + "-header";
+        auto state = create_header_state();
+        g_action_group_change_action_state(action_group, action_name.c_str(), state);
+    }
+
+    std::shared_ptr<const State> m_state;
+    std::shared_ptr<Actions> m_actions;
+    std::shared_ptr<const Formatter> m_formatter;
+    GMenu* m_submenu = nullptr;
+
+    GVariant* get_serialized_alarm_icon() { return m_serialized_alarm_icon; }
+
+private:
+
+    /* try to get the clock app's filename from click. (/$pkgdir/$icon) */
+    static GVariant* create_alarm_icon()
+    {
+        GVariant* serialized = nullptr;
+        gchar* icon_filename = nullptr;
+        gchar* standard_error = nullptr;
+        gchar* pkgdir = nullptr;
+
+        g_spawn_command_line_sync("click pkgdir com.ubuntu.clock", &pkgdir, &standard_error, nullptr, nullptr);
+        g_clear_pointer(&standard_error, g_free);
+        if (pkgdir != nullptr)
+        {
+            gchar* manifest = nullptr;
+            g_strstrip(pkgdir);
+            g_spawn_command_line_sync("click info com.ubuntu.clock", &manifest, &standard_error, nullptr, nullptr);
+            g_clear_pointer(&standard_error, g_free);
+            if (manifest != nullptr)
+            {
+                JsonParser* parser = json_parser_new();
+                if (json_parser_load_from_data(parser, manifest, -1, nullptr))
+                {
+                    JsonNode* root = json_parser_get_root(parser); /* transfer-none */
+                    if ((root != nullptr) && (JSON_NODE_TYPE(root) == JSON_NODE_OBJECT))
+                    {
+                        JsonObject* o = json_node_get_object(root); /* transfer-none */
+                        const gchar* icon_name = json_object_get_string_member(o, "icon");
+                        if (icon_name != nullptr)
+                            icon_filename = g_build_filename(pkgdir, icon_name, nullptr);
+                    }
+                }
+                g_object_unref(parser);
+                g_free(manifest);
+            }
+            g_free(pkgdir);
+        }
+
+        if (icon_filename != nullptr)
+        {
+            GFile* file = g_file_new_for_path(icon_filename);
+            GIcon* icon = g_file_icon_new(file);
+
+            serialized = g_icon_serialize(icon);
+
+            g_object_unref(icon);
+            g_object_unref(file);
+            g_free(icon_filename);
+        }
+
+        if (serialized == nullptr)
+        {
+            auto i = g_themed_icon_new_with_default_fallbacks(FALLBACK_ALARM_CLOCK_ICON_NAME);
+            serialized = g_icon_serialize(i);
+            g_object_unref(i);
+        }
+
+        return serialized;
+    }
+
+    GVariant* get_serialized_calendar_icon()
+    {
+        if (G_UNLIKELY(m_serialized_calendar_icon == nullptr))
+        {
+            auto i = g_themed_icon_new_with_default_fallbacks(CALENDAR_ICON_NAME);
+            m_serialized_calendar_icon = g_icon_serialize(i);
+            g_object_unref(i);
+        }
+
+        return m_serialized_calendar_icon;
+    }
+
+    void create_gmenu()
+    {
+        g_assert(m_submenu == nullptr);
+
+        m_submenu = g_menu_new();
+
+        // build placeholders for the sections
+        for(int i=0; i<NUM_SECTIONS; i++)
+        {
+            GMenuItem * item = g_menu_item_new(nullptr, nullptr);
+            g_menu_append_item(m_submenu, item);
+            g_object_unref(item);
+        }
+
+        // add submenu to the header
+        const auto detailed_action = std::string("indicator.") + name() + "-header";
+        auto header = g_menu_item_new(nullptr, detailed_action.c_str());
+        g_menu_item_set_attribute(header, "x-canonical-type", "s",
+                                  "com.canonical.indicator.root");
+        g_menu_item_set_attribute(header, "submenu-action", "s",
+                                  "indicator.calendar-active");
+        g_menu_item_set_submenu(header, G_MENU_MODEL(m_submenu));
+        g_object_unref(m_submenu);
+
+        // add header to the menu
+        m_menu = g_menu_new();
+        g_menu_append_item(m_menu, header);
+        g_object_unref(header);
+    }
+
+    GMenuModel* create_calendar_section(Profile profile)
+    {
+        const bool allow_activation = (profile == Desktop)
+                                   || (profile == Phone);
+        const bool show_calendar = m_state->settings->show_calendar.get() &&
+                                   ((profile == Desktop) || (profile == DesktopGreeter));
+        auto menu = g_menu_new();
+
+        // add a menuitem that shows the current date
+        auto label = m_state->clock->localtime().format(_("%A, %e %B %Y"));
+        auto item = g_menu_item_new (label.c_str(), nullptr);
+        auto v = get_serialized_calendar_icon();
+        g_menu_item_set_attribute_value (item, G_MENU_ATTRIBUTE_ICON, v);
+        if (allow_activation)
+        {
+            v = g_variant_new_int64(0);
+            const char* action = "indicator.activate-planner";
+            g_menu_item_set_action_and_target_value (item, action, v);
+        }
+        g_menu_append_item(menu, item);
+        g_object_unref(item);
+
+        // add calendar
+        if (show_calendar)
+        {
+            item = g_menu_item_new ("[calendar]", NULL);
+            v = g_variant_new_int64(0);
+            g_menu_item_set_action_and_target_value (item, "indicator.calendar", v);
+            g_menu_item_set_attribute (item, "x-canonical-type",
+                                       "s", "com.canonical.indicator.calendar");
+            if (allow_activation)
+            {
+                g_menu_item_set_attribute (item, "activation-action",
+                                           "s", "indicator.activate-planner");
+            }
+            g_menu_append_item (menu, item);
+            g_object_unref (item);
+        }
+
+        return G_MENU_MODEL(menu);
+    }
+
+    void add_appointments(GMenu* menu, Profile profile)
+    {
+        int n = 0;
+        const int MAX_APPTS = 5;
+        std::set<std::string> added;
+
+        for (const auto& appt : m_state->planner->upcoming.get())
+        {
+            if (n++ >= MAX_APPTS)
+                break;