2013-01-23 17:28:19 +00:00
|
|
|
# Datetime configuration spoke class
|
|
|
|
#
|
2014-04-07 12:38:09 +00:00
|
|
|
# Copyright (C) 2012-2013 Red Hat, Inc.
|
2013-01-23 17:28:19 +00:00
|
|
|
#
|
|
|
|
# This copyrighted material is made available to anyone wishing to use,
|
|
|
|
# modify, copy, or redistribute it subject to the terms and conditions of
|
|
|
|
# the GNU General Public License v.2, or (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
# ANY WARRANTY expressed or implied, including the implied warranties of
|
|
|
|
# MERCHANTABILITY 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, write to the
|
|
|
|
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
|
|
|
|
# source code or documentation are not subject to the GNU General Public
|
|
|
|
# License and may only be used or replicated with the express permission of
|
|
|
|
# Red Hat, Inc.
|
|
|
|
#
|
|
|
|
# Red Hat Author(s): Vratislav Podzimek <vpodzime@redhat.com>
|
|
|
|
#
|
|
|
|
|
|
|
|
import logging
|
|
|
|
log = logging.getLogger("anaconda")
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
from gi.repository import GLib, Gtk, Gdk
|
2013-01-23 17:28:19 +00:00
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
from pyanaconda.ui.communication import hubQ
|
|
|
|
from pyanaconda.ui.common import FirstbootSpokeMixIn
|
2013-01-23 17:28:19 +00:00
|
|
|
from pyanaconda.ui.gui import GUIObject
|
|
|
|
from pyanaconda.ui.gui.spokes import NormalSpoke
|
|
|
|
from pyanaconda.ui.gui.categories.localization import LocalizationCategory
|
2014-04-07 12:38:09 +00:00
|
|
|
from pyanaconda.ui.gui.utils import enlightbox, gtk_action_nowait, gtk_call_once
|
2013-01-23 17:28:19 +00:00
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
from pyanaconda.i18n import _, N_
|
|
|
|
from pyanaconda.timezone import NTP_SERVICE, get_all_regions_and_timezones, is_valid_timezone
|
|
|
|
from pyanaconda.localization import get_xlated_timezone
|
2013-01-23 17:28:19 +00:00
|
|
|
from pyanaconda import iutil
|
2014-04-07 12:38:09 +00:00
|
|
|
from pyanaconda import isys
|
2013-01-23 17:28:19 +00:00
|
|
|
from pyanaconda import network
|
2014-04-07 12:38:09 +00:00
|
|
|
from pyanaconda import nm
|
2013-01-23 17:28:19 +00:00
|
|
|
from pyanaconda import ntp
|
|
|
|
from pyanaconda import flags
|
2014-04-07 12:38:09 +00:00
|
|
|
from pyanaconda import constants
|
2013-01-23 17:28:19 +00:00
|
|
|
from pyanaconda.threads import threadMgr, AnacondaThread
|
|
|
|
|
|
|
|
import datetime
|
|
|
|
import os
|
2014-04-07 12:38:09 +00:00
|
|
|
import re
|
2013-01-23 17:28:19 +00:00
|
|
|
import threading
|
2014-04-07 12:38:09 +00:00
|
|
|
import locale as locale_mod
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
__all__ = ["DatetimeSpoke"]
|
|
|
|
|
|
|
|
SERVER_OK = 0
|
|
|
|
SERVER_NOK = 1
|
|
|
|
SERVER_QUERY = 2
|
|
|
|
|
|
|
|
DEFAULT_TZ = "America/New_York"
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
SPLIT_NUMBER_SUFFIX_RE = re.compile(r'([^0-9]*)([-+])([0-9]+)')
|
|
|
|
|
|
|
|
def _compare_regions(reg_xlated1, reg_xlated2):
|
|
|
|
"""Compare two pairs of regions and their translations."""
|
|
|
|
|
|
|
|
reg1, xlated1 = reg_xlated1
|
|
|
|
reg2, xlated2 = reg_xlated2
|
|
|
|
|
|
|
|
# sort the Etc timezones to the end
|
|
|
|
if reg1 == "Etc" and reg2 == "Etc":
|
|
|
|
return 0
|
|
|
|
elif reg1 == "Etc":
|
|
|
|
return 1
|
|
|
|
elif reg2 == "Etc":
|
|
|
|
return -1
|
|
|
|
else:
|
|
|
|
# otherwise compare the translated names
|
|
|
|
return locale_mod.strcoll(xlated1, xlated2)
|
|
|
|
|
|
|
|
def _compare_cities(city_xlated1, city_xlated2):
|
|
|
|
"""Compare two paris of cities and their translations."""
|
|
|
|
|
|
|
|
# if there are "cities" ending with numbers (like GMT+-X), we need to sort
|
|
|
|
# them based on their numbers
|
|
|
|
val1 = city_xlated1[1]
|
|
|
|
val2 = city_xlated2[1]
|
|
|
|
|
|
|
|
match1 = SPLIT_NUMBER_SUFFIX_RE.match(val1)
|
|
|
|
match2 = SPLIT_NUMBER_SUFFIX_RE.match(val2)
|
|
|
|
|
|
|
|
if match1 is None and match2 is None:
|
|
|
|
# no +-X suffix, just compare the strings
|
|
|
|
return locale_mod.strcoll(val1, val2)
|
|
|
|
|
|
|
|
if match1 is None or match2 is None:
|
|
|
|
# one with the +-X suffix, compare the prefixes
|
|
|
|
if match1:
|
|
|
|
prefix, _sign, _suffix = match1.groups()
|
|
|
|
return locale_mod.strcoll(prefix, val2)
|
|
|
|
else:
|
|
|
|
prefix, _sign, _suffix = match2.groups()
|
|
|
|
return locale_mod.strcoll(val1, prefix)
|
|
|
|
|
|
|
|
# both have the +-X suffix
|
|
|
|
prefix1, sign1, suffix1 = match1.groups()
|
|
|
|
prefix2, sign2, suffix2 = match2.groups()
|
|
|
|
|
|
|
|
if prefix1 == prefix2:
|
|
|
|
# same prefixes, let signs determine
|
|
|
|
return cmp(int(sign1 + suffix1), int(sign2 + suffix2))
|
|
|
|
else:
|
|
|
|
# compare prefixes
|
|
|
|
return locale_mod.strcoll(prefix1, prefix2)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
class NTPconfigDialog(GUIObject):
|
|
|
|
builderObjects = ["ntpConfigDialog", "addImage", "serversStore"]
|
|
|
|
mainWidgetName = "ntpConfigDialog"
|
|
|
|
uiFile = "spokes/datetime_spoke.glade"
|
|
|
|
|
|
|
|
def __init__(self, *args):
|
|
|
|
GUIObject.__init__(self, *args)
|
|
|
|
|
|
|
|
#used to ensure uniqueness of the threads' names
|
|
|
|
self._threads_counter = 0
|
|
|
|
|
|
|
|
#epoch is increased when serversStore is repopulated
|
|
|
|
self._epoch = 0
|
|
|
|
self._epoch_lock = threading.Lock()
|
|
|
|
|
|
|
|
@property
|
|
|
|
def working_server(self):
|
|
|
|
for row in self._serversStore:
|
|
|
|
if row[1] == SERVER_OK and row[2]:
|
|
|
|
#server is checked and working
|
|
|
|
return row[0]
|
|
|
|
|
|
|
|
return None
|
|
|
|
|
|
|
|
@property
|
|
|
|
def servers(self):
|
|
|
|
ret = list()
|
|
|
|
|
|
|
|
for row in self._serversStore:
|
|
|
|
if row[2]:
|
|
|
|
#server checked
|
|
|
|
ret.append(row[0])
|
|
|
|
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def _render_working(self, column, renderer, model, itr, user_data=None):
|
|
|
|
#get the value in the second column
|
|
|
|
value = model[itr][1]
|
|
|
|
|
|
|
|
if value == SERVER_QUERY:
|
|
|
|
renderer.set_property("stock-id", "gtk-dialog-question")
|
|
|
|
elif value == SERVER_OK:
|
|
|
|
renderer.set_property("stock-id", "gtk-yes")
|
|
|
|
else:
|
|
|
|
renderer.set_property("stock-id", "gtk-no")
|
|
|
|
|
|
|
|
def initialize(self):
|
|
|
|
self.window.set_size_request(500, 400)
|
|
|
|
|
|
|
|
workingColumn = self.builder.get_object("workingColumn")
|
|
|
|
workingRenderer = self.builder.get_object("workingRenderer")
|
|
|
|
workingColumn.set_cell_data_func(workingRenderer, self._render_working)
|
|
|
|
|
|
|
|
self._serverEntry = self.builder.get_object("serverEntry")
|
|
|
|
self._serversStore = self.builder.get_object("serversStore")
|
|
|
|
|
|
|
|
self._initialize_store_from_config()
|
|
|
|
|
|
|
|
def _initialize_store_from_config(self):
|
|
|
|
self._serversStore.clear()
|
|
|
|
|
|
|
|
if self.data.timezone.ntpservers:
|
|
|
|
for server in self.data.timezone.ntpservers:
|
|
|
|
self._add_server(server)
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
for server in ntp.get_servers_from_config():
|
|
|
|
self._add_server(server)
|
2014-04-07 12:38:09 +00:00
|
|
|
except ntp.NTPconfigError:
|
2013-01-23 17:28:19 +00:00
|
|
|
log.warning("Failed to load NTP servers configuration")
|
|
|
|
|
|
|
|
def refresh(self):
|
|
|
|
self._serverEntry.grab_focus()
|
|
|
|
|
|
|
|
def refresh_servers_state(self):
|
|
|
|
itr = self._serversStore.get_iter_first()
|
|
|
|
while itr:
|
|
|
|
self._refresh_server_working(itr)
|
|
|
|
itr = self._serversStore.iter_next(itr)
|
|
|
|
|
|
|
|
def run(self):
|
|
|
|
self.window.show()
|
|
|
|
rc = self.window.run()
|
|
|
|
self.window.hide()
|
|
|
|
|
|
|
|
#OK clicked
|
|
|
|
if rc == 1:
|
|
|
|
new_servers = list()
|
|
|
|
|
|
|
|
for row in self._serversStore:
|
|
|
|
#if server checked
|
|
|
|
if row[2]:
|
|
|
|
new_servers.append(row[0])
|
|
|
|
|
|
|
|
if flags.can_touch_runtime_system("save NTP servers configuration"):
|
|
|
|
ntp.save_servers_to_config(new_servers)
|
2014-04-07 12:38:09 +00:00
|
|
|
iutil.restart_service(NTP_SERVICE)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
#Cancel clicked, window destroyed...
|
|
|
|
else:
|
|
|
|
self._epoch_lock.acquire()
|
|
|
|
self._epoch += 1
|
|
|
|
self._epoch_lock.release()
|
|
|
|
|
|
|
|
self._initialize_store_from_config()
|
|
|
|
|
|
|
|
return rc
|
|
|
|
|
|
|
|
def _set_server_ok_nok(self, itr, epoch_started):
|
|
|
|
"""
|
|
|
|
If the server is working, set its data to SERVER_OK, otherwise set its
|
|
|
|
data to SERVER_NOK.
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
:param itr: iterator of the $server's row in the self._serversStore
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
"""
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
@gtk_action_nowait
|
2013-01-23 17:28:19 +00:00
|
|
|
def set_store_value(arg_tuple):
|
|
|
|
"""
|
|
|
|
We need a function for this, because this way it can be added to
|
|
|
|
the MainLoop with thread-safe GLib.idle_add (but only with one
|
|
|
|
argument).
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
:param arg_tuple: (store, itr, column, value)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
(store, itr, column, value) = arg_tuple
|
|
|
|
store.set_value(itr, column, value)
|
|
|
|
|
|
|
|
orig_hostname = self._serversStore[itr][0]
|
|
|
|
server_working = ntp.ntp_server_working(self._serversStore[itr][0])
|
|
|
|
|
|
|
|
#do not let dialog change epoch while we are modifying data
|
|
|
|
self._epoch_lock.acquire()
|
|
|
|
|
|
|
|
#check if we are in the same epoch as the dialog (and the serversStore)
|
|
|
|
#and if the server wasn't changed meanwhile
|
|
|
|
if epoch_started == self._epoch:
|
|
|
|
actual_hostname = self._serversStore[itr][0]
|
|
|
|
|
|
|
|
if orig_hostname == actual_hostname:
|
|
|
|
if server_working:
|
|
|
|
set_store_value((self._serversStore,
|
|
|
|
itr, 1, SERVER_OK))
|
|
|
|
else:
|
|
|
|
set_store_value((self._serversStore,
|
|
|
|
itr, 1, SERVER_NOK))
|
|
|
|
self._epoch_lock.release()
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
@gtk_action_nowait
|
2013-01-23 17:28:19 +00:00
|
|
|
def _refresh_server_working(self, itr):
|
|
|
|
""" Runs a new thread with _set_server_ok_nok(itr) as a taget. """
|
|
|
|
|
|
|
|
self._serversStore.set_value(itr, 1, SERVER_QUERY)
|
|
|
|
new_thread_name = "AnaNTPserver%d" % self._threads_counter
|
|
|
|
threadMgr.add(AnacondaThread(name=new_thread_name,
|
|
|
|
target=self._set_server_ok_nok,
|
|
|
|
args=(itr, self._epoch)))
|
|
|
|
self._threads_counter += 1
|
|
|
|
|
|
|
|
def _add_server(self, server):
|
|
|
|
"""
|
|
|
|
Checks if a given server is a valid hostname and if yes, adds it
|
|
|
|
to the list of servers.
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
:param server: string containing hostname
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
(valid, error) = network.sanityCheckHostname(server)
|
|
|
|
if not valid:
|
2014-04-07 12:38:09 +00:00
|
|
|
log.error("'%s' is not a valid hostname: %s", server, error)
|
2013-01-23 17:28:19 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
for row in self._serversStore:
|
|
|
|
if row[0] == server:
|
|
|
|
#do not add duplicate items
|
|
|
|
return
|
|
|
|
|
|
|
|
itr = self._serversStore.append([server, SERVER_QUERY, True])
|
|
|
|
|
|
|
|
#do not block UI while starting thread (may take some time)
|
|
|
|
self._refresh_server_working(itr)
|
|
|
|
|
|
|
|
def on_entry_activated(self, entry, *args):
|
|
|
|
self._add_server(entry.get_text())
|
|
|
|
entry.set_text("")
|
|
|
|
|
|
|
|
def on_add_clicked(self, *args):
|
|
|
|
self._add_server(self._serverEntry.get_text())
|
|
|
|
self._serverEntry.set_text("")
|
|
|
|
|
|
|
|
def on_use_server_toggled(self, renderer, path, *args):
|
|
|
|
itr = self._serversStore.get_iter(path)
|
|
|
|
old_value = self._serversStore[itr][2]
|
|
|
|
|
|
|
|
self._serversStore.set_value(itr, 2, not old_value)
|
|
|
|
|
|
|
|
def on_server_edited(self, renderer, path, new_text, *args):
|
|
|
|
if not path:
|
|
|
|
return
|
|
|
|
|
|
|
|
(valid, error) = network.sanityCheckHostname(new_text)
|
|
|
|
if not valid:
|
2014-04-07 12:38:09 +00:00
|
|
|
log.error("'%s' is not a valid hostname: %s", new_text, error)
|
2013-01-23 17:28:19 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
itr = self._serversStore.get_iter(path)
|
|
|
|
|
|
|
|
if self._serversStore[itr][0] == new_text:
|
|
|
|
return
|
|
|
|
|
|
|
|
self._serversStore.set_value(itr, 0, new_text)
|
|
|
|
self._serversStore.set_value(itr, 1, SERVER_QUERY)
|
|
|
|
|
|
|
|
self._refresh_server_working(itr)
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
class DatetimeSpoke(FirstbootSpokeMixIn, NormalSpoke):
|
2013-01-23 17:28:19 +00:00
|
|
|
builderObjects = ["datetimeWindow",
|
|
|
|
"days", "months", "years", "regions", "cities",
|
|
|
|
"upImage", "upImage1", "upImage2", "downImage",
|
|
|
|
"downImage1", "downImage2", "downImage3", "configImage",
|
2014-04-07 12:38:09 +00:00
|
|
|
"citiesFilter", "daysFilter",
|
|
|
|
"cityCompletion", "regionCompletion",
|
2013-01-23 17:28:19 +00:00
|
|
|
]
|
|
|
|
|
|
|
|
mainWidgetName = "datetimeWindow"
|
|
|
|
uiFile = "spokes/datetime_spoke.glade"
|
|
|
|
|
|
|
|
category = LocalizationCategory
|
|
|
|
|
|
|
|
icon = "preferences-system-time-symbolic"
|
2014-04-07 12:38:09 +00:00
|
|
|
title = N_("DATE & _TIME")
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def __init__(self, *args):
|
|
|
|
NormalSpoke.__init__(self, *args)
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
# taking values from the kickstart file?
|
|
|
|
self._kickstarted = flags.flags.automatedInstall
|
|
|
|
|
|
|
|
self._config_dialog = None
|
|
|
|
self._update_datetime_timer_id = None
|
|
|
|
self._start_updating_timer_id = None
|
|
|
|
|
2013-01-23 17:28:19 +00:00
|
|
|
def initialize(self):
|
|
|
|
NormalSpoke.initialize(self)
|
|
|
|
self._daysStore = self.builder.get_object("days")
|
|
|
|
self._monthsStore = self.builder.get_object("months")
|
|
|
|
self._yearsStore = self.builder.get_object("years")
|
|
|
|
self._regionsStore = self.builder.get_object("regions")
|
|
|
|
self._citiesStore = self.builder.get_object("cities")
|
|
|
|
self._tzmap = self.builder.get_object("tzmap")
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
# we need to know it the new value is the same as previous or not
|
|
|
|
self._old_region = None
|
|
|
|
self._old_city = None
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
self._regionCombo = self.builder.get_object("regionCombobox")
|
|
|
|
self._cityCombo = self.builder.get_object("cityCombobox")
|
|
|
|
self._monthCombo = self.builder.get_object("monthCombobox")
|
|
|
|
self._dayCombo = self.builder.get_object("dayCombobox")
|
|
|
|
self._yearCombo = self.builder.get_object("yearCombobox")
|
|
|
|
|
|
|
|
self._daysFilter = self.builder.get_object("daysFilter")
|
|
|
|
self._daysFilter.set_visible_func(self.existing_date, None)
|
|
|
|
|
|
|
|
self._citiesFilter = self.builder.get_object("citiesFilter")
|
|
|
|
self._citiesFilter.set_visible_func(self.city_in_region, None)
|
|
|
|
|
|
|
|
self._hoursLabel = self.builder.get_object("hoursLabel")
|
|
|
|
self._minutesLabel = self.builder.get_object("minutesLabel")
|
|
|
|
self._amPmUp = self.builder.get_object("amPmUpButton")
|
|
|
|
self._amPmDown = self.builder.get_object("amPmDownButton")
|
|
|
|
self._amPmLabel = self.builder.get_object("amPmLabel")
|
|
|
|
self._radioButton24h = self.builder.get_object("timeFormatRB")
|
|
|
|
|
|
|
|
self._ntpSwitch = self.builder.get_object("networkTimeSwitch")
|
2014-04-07 12:38:09 +00:00
|
|
|
|
|
|
|
self._regions_zones = get_all_regions_and_timezones()
|
|
|
|
|
|
|
|
self._months_nums = dict()
|
|
|
|
|
|
|
|
threadMgr.add(AnacondaThread(name=constants.THREAD_DATE_TIME,
|
|
|
|
target=self._initialize))
|
|
|
|
|
|
|
|
def _initialize(self):
|
|
|
|
for day in xrange(1, 32):
|
|
|
|
self.add_to_store(self._daysStore, day)
|
|
|
|
|
|
|
|
for i in xrange(1, 13):
|
|
|
|
#a bit hacky way, but should return the translated string
|
|
|
|
#TODO: how to handle language change? Clear and populate again?
|
|
|
|
month = datetime.date(2000, i, 1).strftime('%B')
|
|
|
|
self.add_to_store(self._monthsStore, month)
|
|
|
|
self._months_nums[month] = i
|
|
|
|
|
|
|
|
for year in xrange(1990, 2051):
|
|
|
|
self.add_to_store(self._yearsStore, year)
|
|
|
|
|
|
|
|
cities = set()
|
|
|
|
xlated_regions = ((region, get_xlated_timezone(region))
|
|
|
|
for region in self._regions_zones.iterkeys())
|
|
|
|
for region, xlated in sorted(xlated_regions, cmp=_compare_regions):
|
|
|
|
self.add_to_store_xlated(self._regionsStore, region, xlated)
|
|
|
|
for city in self._regions_zones[region]:
|
|
|
|
cities.add((city, get_xlated_timezone(city)))
|
|
|
|
|
|
|
|
for city, xlated in sorted(cities, cmp=_compare_cities):
|
|
|
|
self.add_to_store_xlated(self._citiesStore, city, xlated)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
if self._radioButton24h.get_active():
|
|
|
|
self._set_amPm_part_sensitive(False)
|
|
|
|
|
|
|
|
self._update_datetime_timer_id = None
|
2014-04-07 12:38:09 +00:00
|
|
|
if is_valid_timezone(self.data.timezone.timezone):
|
|
|
|
self._set_timezone(self.data.timezone.timezone)
|
|
|
|
elif not flags.flags.automatedInstall:
|
|
|
|
log.warning("%s is not a valid timezone, falling back to default (%s)",
|
|
|
|
self.data.timezone.timezone, DEFAULT_TZ)
|
|
|
|
self._set_timezone(DEFAULT_TZ)
|
2013-01-23 17:28:19 +00:00
|
|
|
self.data.timezone.timezone = DEFAULT_TZ
|
|
|
|
|
|
|
|
if not flags.can_touch_runtime_system("modify system time and date"):
|
|
|
|
self._set_date_time_setting_sensitive(False)
|
|
|
|
|
|
|
|
self._config_dialog = NTPconfigDialog(self.data)
|
|
|
|
self._config_dialog.initialize()
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
time_init_thread = threadMgr.get(constants.THREAD_TIME_INIT)
|
|
|
|
if time_init_thread is not None:
|
|
|
|
hubQ.send_message(self.__class__.__name__,
|
|
|
|
_("Restoring hardware time..."))
|
|
|
|
threadMgr.wait(constants.THREAD_TIME_INIT)
|
|
|
|
|
|
|
|
hubQ.send_ready(self.__class__.__name__, False)
|
|
|
|
|
2013-01-23 17:28:19 +00:00
|
|
|
@property
|
|
|
|
def status(self):
|
|
|
|
if self.data.timezone.timezone:
|
2014-04-07 12:38:09 +00:00
|
|
|
if is_valid_timezone(self.data.timezone.timezone):
|
|
|
|
return _("%s timezone") % get_xlated_timezone(self.data.timezone.timezone)
|
2013-01-23 17:28:19 +00:00
|
|
|
else:
|
|
|
|
return _("Invalid timezone")
|
2014-04-07 12:38:09 +00:00
|
|
|
elif self._tzmap.get_timezone():
|
|
|
|
return _("%s timezone") % get_xlated_timezone(self._tzmap.get_timezone())
|
2013-01-23 17:28:19 +00:00
|
|
|
else:
|
2014-04-07 12:38:09 +00:00
|
|
|
return _("Nothing selected")
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def apply(self):
|
2014-04-07 12:38:09 +00:00
|
|
|
# we could use self._tzmap.get_timezone() here, but it returns "" if
|
|
|
|
# Etc/XXXXXX timezone is selected
|
|
|
|
region = self._get_active_region()
|
|
|
|
city = self._get_active_city()
|
|
|
|
# nothing selected, just leave the spoke and
|
|
|
|
# return to hub without changing anything
|
|
|
|
if not region or not city:
|
|
|
|
return
|
2013-01-23 17:28:19 +00:00
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
old_tz = self.data.timezone.timezone
|
|
|
|
new_tz = region + "/" + city
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
self.data.timezone.timezone = new_tz
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
if old_tz != new_tz:
|
|
|
|
# new values, not from kickstart
|
|
|
|
self.data.timezone.seen = False
|
|
|
|
self._kickstarted = False
|
|
|
|
|
|
|
|
self.data.timezone.nontp = not self._ntpSwitch.get_active()
|
|
|
|
|
|
|
|
def execute(self):
|
|
|
|
if self._update_datetime_timer_id is not None:
|
|
|
|
GLib.source_remove(self._update_datetime_timer_id)
|
|
|
|
self._update_datetime_timer_id = None
|
|
|
|
self.data.timezone.setup(self.data)
|
|
|
|
|
|
|
|
@property
|
|
|
|
def ready(self):
|
|
|
|
return not threadMgr.get("AnaDateTimeThread")
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
@property
|
|
|
|
def completed(self):
|
2014-04-07 12:38:09 +00:00
|
|
|
if self._kickstarted and not self.data.timezone.seen:
|
|
|
|
# taking values from kickstart, but not specified
|
|
|
|
return False
|
|
|
|
else:
|
|
|
|
return is_valid_timezone(self.data.timezone.timezone)
|
|
|
|
|
|
|
|
@property
|
|
|
|
def mandatory(self):
|
|
|
|
return True
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def refresh(self):
|
|
|
|
#update the displayed time
|
|
|
|
self._update_datetime_timer_id = GLib.timeout_add_seconds(1,
|
|
|
|
self._update_datetime)
|
|
|
|
self._start_updating_timer_id = None
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
if is_valid_timezone(self.data.timezone.timezone):
|
|
|
|
self._set_timezone(self.data.timezone.timezone)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
self._update_datetime()
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
has_active_network = nm.nm_is_connected()
|
2013-01-23 17:28:19 +00:00
|
|
|
if not has_active_network:
|
|
|
|
self._show_no_network_warning()
|
|
|
|
else:
|
|
|
|
self.clear_info()
|
|
|
|
gtk_call_once(self._config_dialog.refresh_servers_state)
|
|
|
|
|
|
|
|
if flags.can_touch_runtime_system("get NTP service state"):
|
2014-04-07 12:38:09 +00:00
|
|
|
ntp_working = has_active_network and iutil.service_running(NTP_SERVICE)
|
2013-01-23 17:28:19 +00:00
|
|
|
else:
|
|
|
|
ntp_working = not self.data.timezone.nontp
|
|
|
|
|
|
|
|
self._ntpSwitch.set_active(ntp_working)
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
def _set_timezone(self, timezone):
|
|
|
|
"""
|
|
|
|
Sets timezone to the city/region comboboxes and the timezone map.
|
|
|
|
|
|
|
|
:param timezone: timezone to set
|
|
|
|
:type timezone: str
|
|
|
|
:return: if successfully set or not
|
|
|
|
:rtype: bool
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
parts = timezone.split("/", 1)
|
|
|
|
if len(parts) != 2:
|
|
|
|
# invalid timezone cannot be set
|
|
|
|
return False
|
|
|
|
|
|
|
|
region, city = parts
|
|
|
|
self._set_combo_selection(self._regionCombo, region)
|
|
|
|
self._set_combo_selection(self._cityCombo, city)
|
|
|
|
|
|
|
|
return True
|
|
|
|
|
|
|
|
@gtk_action_nowait
|
|
|
|
def add_to_store_xlated(self, store, item, xlated):
|
|
|
|
store.append([item, xlated])
|
|
|
|
|
|
|
|
@gtk_action_nowait
|
2013-01-23 17:28:19 +00:00
|
|
|
def add_to_store(self, store, item):
|
|
|
|
store.append([item])
|
|
|
|
|
|
|
|
def existing_date(self, model, itr, user_data=None):
|
|
|
|
if not itr:
|
|
|
|
return False
|
|
|
|
day = model[itr][0]
|
|
|
|
|
|
|
|
#days 1-28 are in every month every year
|
|
|
|
if day < 29:
|
|
|
|
return True
|
|
|
|
|
|
|
|
months_model = self._monthCombo.get_model()
|
|
|
|
months_iter = self._monthCombo.get_active_iter()
|
|
|
|
if not months_iter:
|
|
|
|
return True
|
|
|
|
month = months_model[months_iter][0]
|
|
|
|
|
|
|
|
years_model = self._yearCombo.get_model()
|
|
|
|
years_iter = self._yearCombo.get_active_iter()
|
|
|
|
if not years_iter:
|
|
|
|
return True
|
|
|
|
year = years_model[years_iter][0]
|
|
|
|
|
|
|
|
try:
|
|
|
|
datetime.date(year, self._months_nums[month], day)
|
|
|
|
return True
|
2014-04-07 12:38:09 +00:00
|
|
|
except ValueError:
|
2013-01-23 17:28:19 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
def _get_active_city(self):
|
|
|
|
cities_model = self._cityCombo.get_model()
|
|
|
|
cities_iter = self._cityCombo.get_active_iter()
|
|
|
|
if not cities_iter:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return cities_model[cities_iter][0]
|
|
|
|
|
|
|
|
def _get_active_region(self):
|
|
|
|
regions_model = self._regionCombo.get_model()
|
|
|
|
regions_iter = self._regionCombo.get_active_iter()
|
|
|
|
if not regions_iter:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return regions_model[regions_iter][0]
|
|
|
|
|
|
|
|
def city_in_region(self, model, itr, user_data=None):
|
|
|
|
if not itr:
|
|
|
|
return False
|
|
|
|
city = model[itr][0]
|
|
|
|
|
|
|
|
region = self._get_active_region()
|
|
|
|
if not region:
|
|
|
|
return False
|
|
|
|
|
|
|
|
return city in self._regions_zones[region]
|
|
|
|
|
|
|
|
def _set_amPm_part_sensitive(self, sensitive):
|
|
|
|
|
|
|
|
for widget in (self._amPmUp, self._amPmDown, self._amPmLabel):
|
|
|
|
widget.set_sensitive(sensitive)
|
|
|
|
|
|
|
|
def _to_amPm(self, hours):
|
|
|
|
if hours >= 12:
|
|
|
|
day_phase = "PM"
|
|
|
|
else:
|
|
|
|
day_phase = "AM"
|
|
|
|
|
|
|
|
new_hours = ((hours - 1) % 12) + 1
|
|
|
|
|
|
|
|
return (new_hours, day_phase)
|
|
|
|
|
|
|
|
def _to_24h(self, hours, day_phase):
|
|
|
|
correction = 0
|
|
|
|
|
|
|
|
if day_phase == "AM" and hours == 12:
|
|
|
|
correction = -12
|
|
|
|
|
|
|
|
elif day_phase == "PM" and hours != 12:
|
|
|
|
correction = 12
|
|
|
|
|
|
|
|
return (hours + correction) % 24
|
|
|
|
|
|
|
|
def _update_datetime(self):
|
|
|
|
now = datetime.datetime.now()
|
|
|
|
if self._radioButton24h.get_active():
|
|
|
|
self._hoursLabel.set_text("%0.2d" % now.hour)
|
|
|
|
else:
|
|
|
|
hours, amPm = self._to_amPm(now.hour)
|
|
|
|
self._hoursLabel.set_text("%0.2d" % hours)
|
|
|
|
self._amPmLabel.set_text(amPm)
|
|
|
|
|
|
|
|
self._minutesLabel.set_text("%0.2d" % now.minute)
|
|
|
|
|
|
|
|
self._set_combo_selection(self._dayCombo, now.day)
|
|
|
|
self._set_combo_selection(self._monthCombo,
|
|
|
|
datetime.date(2000, now.month, 1).strftime('%B'))
|
|
|
|
self._set_combo_selection(self._yearCombo, now.year)
|
|
|
|
|
|
|
|
#GLib's timer is driven by the return value of the function.
|
|
|
|
#It runs the fuction periodically while the returned value
|
|
|
|
#is True.
|
|
|
|
return True
|
|
|
|
|
|
|
|
def _save_system_time(self):
|
|
|
|
"""
|
|
|
|
Returning False from this method removes the timer that would
|
|
|
|
otherwise call it again and again.
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
if not flags.can_touch_runtime_system("save system time"):
|
|
|
|
return False
|
|
|
|
|
|
|
|
month = self._get_combo_selection(self._monthCombo)
|
|
|
|
if not month:
|
|
|
|
return False
|
|
|
|
month = self._months_nums[month]
|
|
|
|
|
|
|
|
year_str = self._get_combo_selection(self._yearCombo)
|
|
|
|
if not year_str:
|
|
|
|
return False
|
|
|
|
year = int(year_str)
|
|
|
|
|
|
|
|
hours = int(self._hoursLabel.get_text())
|
|
|
|
if not self._radioButton24h.get_active():
|
|
|
|
hours = self._to_24h(hours, self._amPmLabel.get_text())
|
|
|
|
|
|
|
|
minutes = int(self._minutesLabel.get_text())
|
|
|
|
|
|
|
|
day = self._get_combo_selection(self._dayCombo)
|
|
|
|
#day may be None if there is no such in the selected year and month
|
|
|
|
if day:
|
|
|
|
day = int(day)
|
2014-04-07 12:38:09 +00:00
|
|
|
isys.set_system_date_time(year, month, day, hours, minutes)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
#start the timer only when the spoke is shown
|
|
|
|
if self._update_datetime_timer_id is not None:
|
|
|
|
self._update_datetime_timer_id = GLib.timeout_add_seconds(1,
|
|
|
|
self._update_datetime)
|
|
|
|
|
|
|
|
#run only once (after first 2 seconds of inactivity)
|
|
|
|
return False
|
|
|
|
|
|
|
|
def _stop_and_maybe_start_time_updating(self, interval=2):
|
|
|
|
"""
|
|
|
|
This method is called in every date/time-setting button's callback.
|
|
|
|
It removes the timer for updating displayed date/time (do not want to
|
|
|
|
change it while user does it manually) and allows us to set new system
|
|
|
|
date/time only after $interval seconds long idle on time-setting buttons.
|
|
|
|
This is done by the _start_updating_timer that is reset in this method.
|
|
|
|
So when there is $interval seconds long idle on date/time-setting
|
|
|
|
buttons, self._save_system_time method is invoked. Since it returns
|
|
|
|
False, this timer is then removed and only reactivated in this method
|
|
|
|
(thus in some date/time-setting button's callback).
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
#do not start timers if the spoke is not shown
|
|
|
|
if self._update_datetime_timer_id is None:
|
|
|
|
self._update_datetime()
|
|
|
|
self._save_system_time()
|
|
|
|
return
|
|
|
|
|
|
|
|
#stop time updating
|
|
|
|
GLib.source_remove(self._update_datetime_timer_id)
|
|
|
|
|
|
|
|
#stop previous $interval seconds timer (see below)
|
|
|
|
if self._start_updating_timer_id:
|
|
|
|
GLib.source_remove(self._start_updating_timer_id)
|
|
|
|
|
|
|
|
#let the user change date/time and after $interval seconds of inactivity
|
|
|
|
#save it as the system time and start updating the displayed date/time
|
|
|
|
self._start_updating_timer_id = GLib.timeout_add_seconds(interval,
|
|
|
|
self._save_system_time)
|
|
|
|
|
|
|
|
def _set_combo_selection(self, combo, item):
|
|
|
|
model = combo.get_model()
|
|
|
|
if not model:
|
|
|
|
return False
|
|
|
|
|
|
|
|
itr = model.get_iter_first()
|
|
|
|
while itr:
|
|
|
|
if model[itr][0] == item:
|
|
|
|
combo.set_active_iter(itr)
|
|
|
|
return True
|
|
|
|
|
|
|
|
itr = model.iter_next(itr)
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
def _get_combo_selection(self, combo):
|
|
|
|
"""
|
|
|
|
Get the selected item of the combobox.
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
:return: selected item or None
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
model = combo.get_model()
|
|
|
|
itr = combo.get_active_iter()
|
|
|
|
if not itr or not model:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return model[itr][0]
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
def _restore_old_city_region(self):
|
|
|
|
"""Restore stored "old" (or last valid) values."""
|
|
|
|
# check if there are old values to go back to
|
|
|
|
if self._old_region and self._old_city:
|
|
|
|
self._set_timezone(self._old_region + "/" + self._old_city)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def on_up_hours_clicked(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating()
|
|
|
|
|
|
|
|
hours = int(self._hoursLabel.get_text())
|
|
|
|
|
|
|
|
if self._radioButton24h.get_active():
|
|
|
|
new_hours = (hours + 1) % 24
|
|
|
|
else:
|
|
|
|
amPm = self._amPmLabel.get_text()
|
|
|
|
#let's not deal with magical AM/PM arithmetics
|
|
|
|
new_hours = self._to_24h(hours, amPm)
|
|
|
|
new_hours, new_amPm = self._to_amPm((new_hours + 1) % 24)
|
|
|
|
self._amPmLabel.set_text(new_amPm)
|
|
|
|
|
|
|
|
new_hours_str = "%0.2d" % new_hours
|
|
|
|
self._hoursLabel.set_text(new_hours_str)
|
|
|
|
|
|
|
|
def on_down_hours_clicked(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating()
|
|
|
|
|
|
|
|
hours = int(self._hoursLabel.get_text())
|
|
|
|
|
|
|
|
if self._radioButton24h.get_active():
|
|
|
|
new_hours = (hours - 1) % 24
|
|
|
|
else:
|
|
|
|
amPm = self._amPmLabel.get_text()
|
|
|
|
#let's not deal with magical AM/PM arithmetics
|
|
|
|
new_hours = self._to_24h(hours, amPm)
|
|
|
|
new_hours, new_amPm = self._to_amPm((new_hours - 1) % 24)
|
|
|
|
self._amPmLabel.set_text(new_amPm)
|
|
|
|
|
|
|
|
new_hours_str = "%0.2d" % new_hours
|
|
|
|
self._hoursLabel.set_text(new_hours_str)
|
|
|
|
|
|
|
|
def on_up_minutes_clicked(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating()
|
|
|
|
|
|
|
|
minutes = int(self._minutesLabel.get_text())
|
|
|
|
minutes_str = "%0.2d" % ((minutes + 1) % 60)
|
|
|
|
self._minutesLabel.set_text(minutes_str)
|
|
|
|
|
|
|
|
def on_down_minutes_clicked(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating()
|
|
|
|
|
|
|
|
minutes = int(self._minutesLabel.get_text())
|
|
|
|
minutes_str = "%0.2d" % ((minutes - 1) % 60)
|
|
|
|
self._minutesLabel.set_text(minutes_str)
|
|
|
|
|
|
|
|
def on_up_ampm_clicked(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating()
|
|
|
|
|
|
|
|
if self._amPmLabel.get_text() == "AM":
|
|
|
|
self._amPmLabel.set_text("PM")
|
|
|
|
else:
|
|
|
|
self._amPmLabel.set_text("AM")
|
|
|
|
|
|
|
|
def on_down_ampm_clicked(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating()
|
|
|
|
|
|
|
|
if self._amPmLabel.get_text() == "AM":
|
|
|
|
self._amPmLabel.set_text("PM")
|
|
|
|
else:
|
|
|
|
self._amPmLabel.set_text("AM")
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
def on_region_changed(self, combo, *args):
|
|
|
|
"""
|
|
|
|
:see: on_city_changed
|
|
|
|
|
|
|
|
"""
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
region = self._get_active_region()
|
2014-04-07 12:38:09 +00:00
|
|
|
|
|
|
|
if not region or region == self._old_region:
|
|
|
|
# region entry being edited or old_value chosen, no action needed
|
|
|
|
# @see: on_city_changed
|
2013-01-23 17:28:19 +00:00
|
|
|
return
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
self._citiesFilter.refilter()
|
|
|
|
|
|
|
|
# Set the city to the first one available in this newly selected region.
|
2013-01-23 17:28:19 +00:00
|
|
|
zone = self._regions_zones[region]
|
|
|
|
firstCity = sorted(list(zone))[0]
|
|
|
|
|
|
|
|
self._set_combo_selection(self._cityCombo, firstCity)
|
2014-04-07 12:38:09 +00:00
|
|
|
self._old_region = region
|
|
|
|
self._old_city = firstCity
|
|
|
|
|
|
|
|
def on_city_changed(self, combo, *args):
|
|
|
|
"""
|
|
|
|
ComboBox emits ::changed signal not only when something is selected, but
|
|
|
|
also when its entry's text is changed. We need to distinguish between
|
|
|
|
those two cases ('London' typed in the entry => no action until ENTER is
|
|
|
|
hit etc.; 'London' chosen in the expanded combobox => update timezone
|
|
|
|
map and do all necessary actions). Fortunately when entry is being
|
|
|
|
edited, self._get_active_city returns None.
|
|
|
|
|
|
|
|
"""
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
timezone = None
|
|
|
|
|
|
|
|
region = self._get_active_region()
|
|
|
|
city = self._get_active_city()
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
if not region or not city or (region == self._old_region and
|
|
|
|
city == self._old_city):
|
|
|
|
# entry being edited or no change, no actions needed
|
|
|
|
return
|
|
|
|
|
2013-01-23 17:28:19 +00:00
|
|
|
if city and region:
|
|
|
|
timezone = region + "/" + city
|
2014-04-07 12:38:09 +00:00
|
|
|
else:
|
|
|
|
# both city and region are needed to form a valid timezone
|
|
|
|
return
|
2013-01-23 17:28:19 +00:00
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
if region == "Etc":
|
2013-01-23 17:28:19 +00:00
|
|
|
# Etc timezones cannot be displayed on the map, so let's set the map
|
|
|
|
# to "" which sets it to "Europe/London" (UTC) without a city pin
|
2014-04-07 12:38:09 +00:00
|
|
|
self._tzmap.set_timezone("", no_signal=True)
|
|
|
|
else:
|
|
|
|
# we don't want the timezone-changed signal to be emitted
|
|
|
|
self._tzmap.set_timezone(timezone, no_signal=True)
|
|
|
|
|
|
|
|
# update "old" values
|
|
|
|
self._old_city = city
|
|
|
|
|
|
|
|
def on_entry_left(self, entry, *args):
|
|
|
|
# user clicked somewhere else or hit TAB => finished editing
|
|
|
|
entry.emit("activate")
|
|
|
|
|
|
|
|
def on_city_region_key_released(self, entry, event, *args):
|
|
|
|
if event.type == Gdk.EventType.KEY_RELEASE and \
|
|
|
|
event.keyval == Gdk.KEY_Escape:
|
|
|
|
# editing canceled
|
|
|
|
self._restore_old_city_region()
|
|
|
|
|
|
|
|
def on_completion_match_selected(self, combo, model, itr):
|
|
|
|
item = None
|
|
|
|
if model and itr:
|
|
|
|
item = model[itr][0]
|
|
|
|
if item:
|
|
|
|
self._set_combo_selection(combo, item)
|
|
|
|
|
|
|
|
def on_city_region_text_entry_activated(self, entry):
|
|
|
|
combo = entry.get_parent()
|
|
|
|
model = combo.get_model()
|
|
|
|
entry_text = entry.get_text().lower()
|
2013-01-23 17:28:19 +00:00
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
for row in model:
|
|
|
|
if entry_text == row[0].lower():
|
|
|
|
self._set_combo_selection(combo, row[0])
|
|
|
|
return
|
2013-01-23 17:28:19 +00:00
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
# non-matching value entered, reset to old values
|
|
|
|
self._restore_old_city_region()
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def on_month_changed(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating(interval=5)
|
|
|
|
self._daysFilter.refilter()
|
|
|
|
|
|
|
|
def on_day_changed(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating(interval=5)
|
|
|
|
|
|
|
|
def on_year_changed(self, *args):
|
|
|
|
self._stop_and_maybe_start_time_updating(interval=5)
|
|
|
|
self._daysFilter.refilter()
|
|
|
|
|
|
|
|
def on_timezone_changed(self, tz_map, timezone):
|
2014-04-07 12:38:09 +00:00
|
|
|
if self._set_timezone(timezone):
|
|
|
|
# timezone successfully set
|
|
|
|
os.environ["TZ"] = timezone
|
|
|
|
self._update_datetime()
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def on_timeformat_changed(self, button24h, *args):
|
|
|
|
hours = int(self._hoursLabel.get_text())
|
|
|
|
amPm = self._amPmLabel.get_text()
|
|
|
|
|
|
|
|
#connected to 24-hour radio button
|
|
|
|
if button24h.get_active():
|
|
|
|
self._set_amPm_part_sensitive(False)
|
|
|
|
new_hours = self._to_24h(hours, amPm)
|
|
|
|
|
|
|
|
else:
|
|
|
|
self._set_amPm_part_sensitive(True)
|
|
|
|
new_hours, new_amPm = self._to_amPm(hours)
|
|
|
|
self._amPmLabel.set_text(new_amPm)
|
|
|
|
|
|
|
|
self._hoursLabel.set_text("%0.2d" % new_hours)
|
|
|
|
|
|
|
|
def _set_date_time_setting_sensitive(self, sensitive):
|
|
|
|
#contains all date/time setting widgets
|
|
|
|
footer_alignment = self.builder.get_object("footerAlignment")
|
|
|
|
footer_alignment.set_sensitive(sensitive)
|
|
|
|
|
|
|
|
def _show_no_network_warning(self):
|
|
|
|
self.set_warning(_("You need to set up networking first if you "\
|
|
|
|
"want to use NTP"))
|
2014-04-07 12:38:09 +00:00
|
|
|
self.window.show_all()
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def _show_no_ntp_server_warning(self):
|
|
|
|
self.set_warning(_("You have no working NTP server configured"))
|
2014-04-07 12:38:09 +00:00
|
|
|
self.window.show_all()
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
def on_ntp_switched(self, switch, *args):
|
|
|
|
if switch.get_active():
|
|
|
|
#turned ON
|
|
|
|
if not flags.can_touch_runtime_system("start NTP service"):
|
|
|
|
#cannot touch runtime system, not much to do here
|
|
|
|
return
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
if not nm.nm_is_connected():
|
2013-01-23 17:28:19 +00:00
|
|
|
self._show_no_network_warning()
|
|
|
|
switch.set_active(False)
|
|
|
|
return
|
|
|
|
else:
|
|
|
|
self.clear_info()
|
|
|
|
|
|
|
|
working_server = self._config_dialog.working_server
|
|
|
|
if working_server is None:
|
|
|
|
self._show_no_ntp_server_warning()
|
|
|
|
else:
|
|
|
|
#we need a one-time sync here, because chronyd would not change
|
|
|
|
#the time as drastically as we need
|
|
|
|
ntp.one_time_sync_async(working_server)
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
ret = iutil.start_service(NTP_SERVICE)
|
2013-01-23 17:28:19 +00:00
|
|
|
self._set_date_time_setting_sensitive(False)
|
|
|
|
|
|
|
|
#if starting chronyd failed and chronyd is not running,
|
|
|
|
#set switch back to OFF
|
2014-04-07 12:38:09 +00:00
|
|
|
if (ret != 0) and not iutil.service_running(NTP_SERVICE):
|
2013-01-23 17:28:19 +00:00
|
|
|
switch.set_active(False)
|
|
|
|
|
|
|
|
else:
|
|
|
|
#turned OFF
|
|
|
|
if not flags.can_touch_runtime_system("stop NTP service"):
|
|
|
|
#cannot touch runtime system, nothing to do here
|
|
|
|
return
|
|
|
|
|
|
|
|
self._set_date_time_setting_sensitive(True)
|
2014-04-07 12:38:09 +00:00
|
|
|
ret = iutil.stop_service(NTP_SERVICE)
|
2013-01-23 17:28:19 +00:00
|
|
|
|
|
|
|
#if stopping chronyd failed and chronyd is running,
|
|
|
|
#set switch back to ON
|
2014-04-07 12:38:09 +00:00
|
|
|
if (ret != 0) and iutil.service_running(NTP_SERVICE):
|
2013-01-23 17:28:19 +00:00
|
|
|
switch.set_active(True)
|
|
|
|
|
2014-04-07 12:38:09 +00:00
|
|
|
self.clear_info()
|
|
|
|
|
2013-01-23 17:28:19 +00:00
|
|
|
def on_ntp_config_clicked(self, *args):
|
|
|
|
self._config_dialog.refresh()
|
|
|
|
|
|
|
|
with enlightbox(self.window, self._config_dialog.window):
|
|
|
|
response = self._config_dialog.run()
|
|
|
|
|
|
|
|
if response == 1:
|
|
|
|
self.data.timezone.ntpservers = self._config_dialog.servers
|
|
|
|
|
|
|
|
if self._config_dialog.working_server is None:
|
|
|
|
self._show_no_ntp_server_warning()
|
|
|
|
else:
|
|
|
|
self.clear_info()
|
|
|
|
|