Attachment #5474 for bug #27381

View | Details | Raw Unified | Return to bug 27381
Collapse All | Expand All




    import gconf
    import json
    import dbus
    import tz
    import time
    from datetime import datetime
    from user import home
    import thread
except Exception, detail:

            value = self.model[tree_iter][0]            
            self.settings.set_string(self.key, value)                       

class TimeZoneSelectorWidget(Gtk.HBox):
    def __init__(self):
        super(TimeZoneSelectorWidget, self).__init__()
        
        proxy = dbus.SystemBus().get_object("org.gnome.SettingsDaemon.DateTimeMechanism", "/")
        self.dbus_iface = dbus.Interface(proxy, dbus_interface="org.gnome.SettingsDaemon.DateTimeMechanism")
        
        self.timezones = tz.load_db()
        
        self.selected_region, self.selected_city = self.get_selected_zone()
        
        region_label = Gtk.Label(_("Region"))
        self.pack_start(region_label, False, False, 2)
        
        regions = self.timezones.keys()
        regions.sort()
        self.region_model = Gtk.ListStore(str, str)
        selected_region_iter = None
        for region in regions:
            iter = self.region_model.insert_before(None, None)
            self.region_model.set_value(iter, 0, region)                
            self.region_model.set_value(iter, 1, region.replace("_", " "))                        
            if (region == self.selected_region):
                selected_region_iter = iter
                                
        self.region_widget = Gtk.ComboBox.new_with_model(self.region_model)   
        renderer_text = Gtk.CellRendererText()
        self.region_widget.pack_start(renderer_text, True)
        self.region_widget.add_attribute(renderer_text, "text", 1)
        if selected_region_iter is not None:
            self.region_widget.set_active_iter(selected_region_iter)
        self.pack_start(self.region_widget, False, False, 2)
        
        city_label = Gtk.Label(_("City"))
        self.pack_start(city_label, False, False, 2)
        
        self.city_model = Gtk.ListStore(str, str)
        self.city_widget = Gtk.ComboBox.new_with_model(self.city_model)   
        renderer_text = Gtk.CellRendererText()
        self.city_widget.pack_start(renderer_text, True)
        self.city_widget.add_attribute(renderer_text, "text", 1)
        self.pack_start(self.city_widget, False, False, 2)
        
        self.update_cities_list()
        
        self.region_widget.connect("changed", self.on_region_changed)
        self.city_widget.connect("changed", self.on_city_changed)
    def on_city_changed(self, widget):
        tree_iter = widget.get_active_iter()
        if tree_iter != None:
            self.selected_city = self.city_model[tree_iter][0]
            self.dbus_iface.SetTimezone(self.selected_region+"/"+self.selected_city)
    def on_region_changed(self, widget):
        tree_iter = widget.get_active_iter()
        if tree_iter != None:            
            self.selected_region = self.region_model[tree_iter][0]
            self.update_cities_list()
    def update_cities_list(self):
        self.city_model.clear()
        if self.selected_region and self.selected_region in self.timezones.keys():
            cities = self.timezones[self.selected_region]
            cities.sort()
            selected_city_iter = None
            for city in cities:
                iter = self.city_model.insert_before(None, None)
                self.city_model.set_value(iter, 0, city)                
                self.city_model.set_value(iter, 1, city.replace("_", " "))                        
                if (city == self.selected_city):
                    selected_city_iter = iter
            if selected_city_iter is not None:
                self.city_widget.set_active_iter(selected_city_iter)
    def get_selected_zone(self):
        tz = self.dbus_iface.GetTimezone()
        if "/" in tz:
            i = tz.index("/")
            region = tz[:i]
            city = tz[i+1:]
            return region, city
        else:
            return "", ""
            
class ChangeTimeWidget(Gtk.HBox):
    def __init__(self):
        super(ChangeTimeWidget, self).__init__()
        proxy = dbus.SystemBus().get_object("org.gnome.SettingsDaemon.DateTimeMechanism", "/")
        self.dbus_iface = dbus.Interface(proxy, dbus_interface="org.gnome.SettingsDaemon.DateTimeMechanism")
        
        # Ensures we are setting the system time only when the user changes it
        self.changedOnTimeout = False
        
        # Ensures we do not update the values in the date/time fields during the DBus call to set the time
        self._setting_time = False
        self._setting_time_lock = thread.allocate()
        self._time_to_set = None
        
        self.thirtyDays = [3, 5, 8, 10]
        months = ['January','February','March','April','May','June','July','August','September','October','November','December']
        
        # Boxes
        timeBox = Gtk.HBox()
        dateBox = Gtk.HBox()
        
        # Combo Boxes
        self.monthBox = Gtk.ComboBoxText()
        
        for month in months:
            self.monthBox.append_text(month)
        
        # Adjustments
        hourAdj = Gtk.Adjustment(0, 0, 23, 1, 1)
        minAdj = Gtk.Adjustment(0, 0, 59, 1, 1)
        yearAdj = Gtk.Adjustment(0, 0, 9999, 1, 5)
        dayAdj = Gtk.Adjustment(0, 1, 31, 1, 1)
        
        # Spin buttons
        self.hourSpin = Gtk.SpinButton()
        self.minSpin = Gtk.SpinButton()
        self.yearSpin = Gtk.SpinButton()
        self.daySpin = Gtk.SpinButton()
        
        self.hourSpin.configure(hourAdj, 0.5, 0)
        self.minSpin.configure(minAdj, 0.5, 0)
        self.yearSpin.configure(yearAdj, 0.5, 0)
        self.daySpin.configure(dayAdj, 0.5, 0)
        #self.hourSpin.set_editable(False)
        #self.minSpin.set_editable(False)
        #self.yearSpin.set_editable(False)
        #self.daySpin.set_editable(False)
        
        self.update_time()
        GObject.timeout_add(1000, self.update_time)
        
        # Connect to callback
        self.hourSpin.connect('changed', self._change_system_time)
        self.minSpin.connect('changed', self._change_system_time)
        self.monthBox.connect('changed', self._change_system_time)
        self.yearSpin.connect('changed', self._change_system_time)
        self.daySpin.connect('changed', self._change_system_time)
        
        timeBox.pack_start(self.hourSpin, False, False, 2)
        timeBox.pack_start(Gtk.Label(_(":")), False, False, 2)
        timeBox.pack_start(self.minSpin, False, False, 2)
        
        dateBox.pack_start(self.monthBox, False, False, 2)
        dateBox.pack_start(self.daySpin, False, False, 2)
        dateBox.pack_start(self.yearSpin, False, False, 2)
        
        self.pack_start(Gtk.Label(_("Date : ")), False, False, 2)
        self.pack_start(dateBox, True, True, 2)
        self.pack_start(Gtk.Label(_("Time : ")), False, False, 2)
        self.pack_start(timeBox, True, True, 2)
        
    def update_time(self):
        self._setting_time_lock.acquire()
        do_update = not self._setting_time
        self._setting_time_lock.release()
        
        if not do_update:
            return True
        
        dt = datetime.now()
        
        self.changedOnTimeout = True
        
        # Time
        self.hourSpin.set_value( dt.hour )
        self.minSpin.set_value( dt.minute )
        
        # Date
        self.monthBox.set_active( dt.month-1 )
        self.daySpin.set_value( dt.day )
        self.yearSpin.set_value( dt.year )
        
        self.changedOnTimeout = False
        
        # Update the max of the day spin box
        maxDay = 31
        if dt.month == 2:
            if dt.year % 4 == 0:
                maxDay = 29
            else:
                maxDay = 28
        elif dt.month-1 in self.thirtyDays:
            maxDay = 30
            
        self.daySpin.get_adjustment().set_upper(maxDay)
        
        return True
        
    def change_using_ntp(self, usingNtp):
        # Check if we were using Ntp by seeing if the spin button
        # is sensitive
        self.set_sensitive(not usingNtp)
    
    def _do_change_system_time(self):
        self._setting_time_lock.acquire()
        do_set = not self._setting_time
        self._setting_time = True
        self._setting_time_lock.release()
        
        # If there is already another thread updating the time, we let it do the job
        if not do_set:
            return
        
        done = False
        while not done:
            self._setting_time_lock.acquire()
            time_to_set = self._time_to_set
            self._time_to_set = None
            self._setting_time_lock.release()
            
            self.dbus_iface.SetTime(time_to_set)
            
            # Check whether another request to set the time was done since this thread started
            self._setting_time_lock.acquire()
            if self._time_to_set==None:
                done = True
            self._setting_time_lock.release()
        
        self._setting_time_lock.acquire()
        self._setting_time = False
        self._setting_time_lock.release()
                
    def _change_system_time(self, widget):
        if not self.changedOnTimeout:
            hour = int( self.hourSpin.get_value() )
            minute = int( self.minSpin.get_value() )
            month = self.monthBox.get_active() + 1
            day = int( self.daySpin.get_value() )
            year = int( self.yearSpin.get_value() )
            
            newDt = datetime(year, month, day, hour, minute)
            
            self._setting_time_lock.acquire()
            self._time_to_set = time.mktime(newDt.utctimetuple())
            self._setting_time_lock.release()
            
            thread.start_new_thread(self._do_change_system_time, ())

class TitleBarButtonsOrderSelector(Gtk.Table):
    def __init__(self):
        self.key = "/desktop/cinnamon/windows/button_layout"

        sidePage.add_widget(GSettingsCheckButton(_("Panel Launchers draggable"), "org.cinnamon", "panel-launchers-draggable"))       
        
        sidePage = SidePage(_("Calendar"), "clock.svg", self.content_box)
        self.sidePages.append((sidePage, "calendar"))     
        self.changeTimeWidget = ChangeTimeWidget()     
        sidePage.add_widget(GSettingsCheckButton(_("Show week dates in calendar"), "org.cinnamon.calendar", "show-weekdate"))         
        sidePage.add_widget(GSettingsEntry(_("Date format for the panel"), "org.cinnamon.calendar", "date-format"))                                 
        sidePage.add_widget(GSettingsEntry(_("Date format inside the date applet"), "org.cinnamon.calendar", "date-format-full"))                                 
        sidePage.add_widget(Gtk.LinkButton.new_with_label("http://www.foragoodstrftime.com/", _("Generate your own date formats")))

        try:
            self.ntpCheckButton = DBusCheckButton(_("Use network time"), "org.gnome.SettingsDaemon.DateTimeMechanism", "/", "GetUsingNtp", "SetUsingNtp")
            sidePage.add_widget(self.ntpCheckButton)
        except:
            pass
        sidePage.add_widget(self.changeTimeWidget)
        try:
            sidePage.add_widget(TimeZoneSelectorWidget())
        except:
            pass
        
        if self.ntpCheckButton != None:
            self.ntpCheckButton.connect('toggled', self._ntp_toggled)
            self.changeTimeWidget.change_using_ntp( self.ntpCheckButton.get_active() )
        
        sidePage = SidePage(_("Hot corner"), "overview.svg", self.content_box)
        self.sidePages.append((sidePage, "hotcorner"))

        sidePage.add_widget(GSettingsFontButton(_("Default font"), "org.gnome.desktop.interface", "font-name"))
        sidePage.add_widget(GSettingsFontButton(_("Document font"), "org.gnome.desktop.interface", "document-font-name"))
        sidePage.add_widget(GSettingsFontButton(_("Monospace font"), "org.gnome.desktop.interface", "monospace-font-name"))
        sidePage.add_widget(GConfFontButton(_("Window title font"), "/apps/metacity/general/titlebar_font"))
        sidePage.add_widget(GSettingsComboBox(_("Hinting"), "org.gnome.settings-daemon.plugins.xsettings", "hinting", [(i, i.title()) for i in ("none", "slight", "medium", "full")]))
        sidePage.add_widget(GSettingsComboBox(_("Antialiasing"), "org.gnome.settings-daemon.plugins.xsettings", "antialiasing", [(i, i.title()) for i in ("none", "grayscale", "rgba")]))
                        

        self.content_box_sw.hide()
        self.top_button_box.hide()
        self.side_view_sw.show_all()
        
    def _ntp_toggled(self, widget):
        self.changeTimeWidget.change_using_ntp( self.ntpCheckButton.get_active() )
                
                
if __name__ == "__main__":




import os

def load_db():
    tz_db = {}
    
    filename = '/usr/share/zoneinfo/zone.tab'
    if not os.path.exists(filename):
        filename = '/usr/share/lib/zoneinfo/tab/zone_sun.tab'
    if not os.path.exists(filename):
        return {}
        
    tz_file = open(filename)
    
    for line in tz_file:
        line = line.rstrip().lstrip()
        if line=="" or line[0] == '#':
            continue
        
        tz_info = line.split('\t')
        if len(tz_info)<3:
            continue
        tz = tz_info[2]
        if "/" in tz:
            i = tz.index("/")
            region = tz[:i]
            zone = tz[i+1:]
        
            if region not in tz_db:
                tz_db[region] = []
            
            tz_db[region].append(zone)
        
    tz_file.close()
    
    return tz_db




            this._calendar = new Calendar.Calendar(this._eventSource);       
            vbox.add(this._calendar.actor);

            item = this.menu.addSettingsAction(_("Date and Time Settings"), 'gnome-datetime-panel.desktop');
            item.connect("activate", Lang.bind(this, this._onLaunchSettings));
            //this.menu.addMenuItem(item);
            if (item) {
                let separator = new PopupMenu.PopupSeparatorMenuItem();
                separator.setColumnWidths(1);

    on_applet_clicked: function(event) {
        this.menu.toggle();
    },
    
    _onLaunchSettings: function() {
        this.menu.close();
        Util.spawnCommandLine("cinnamon-settings calendar");
    },

    _updateClockAndDate: function() {
        let dateFormat = this._calendarSettings.get_string('date-format');       

Return to bug 27381

Lines 62-70 MyApplet.prototype = { Link Here

(-)a/files/usr/share/cinnamon/applets/calendar@cinnamon.org/applet.js (-8 / +1 lines)
62	this._calendar = new Calendar.Calendar(this._eventSource);	62	this._calendar = new Calendar.Calendar(this._eventSource);
63	vbox.add(this._calendar.actor);	63	vbox.add(this._calendar.actor);
64		64
65	let item = new PopupMenu.PopupMenuItem(_("Date and Time Settings"))	65	item = this.menu.addSettingsAction(_("Date and Time Settings"), 'gnome-datetime-panel.desktop');
66	item.connect("activate", Lang.bind(this, this._onLaunchSettings));
67	//this.menu.addMenuItem(item);
68	if (item) {	66	if (item) {
69	let separator = new PopupMenu.PopupSeparatorMenuItem();	67	let separator = new PopupMenu.PopupSeparatorMenuItem();
70	separator.setColumnWidths(1);	68	separator.setColumnWidths(1);
Lines 96-106 MyApplet.prototype = { Link Here
96	on_applet_clicked: function(event) {	94	on_applet_clicked: function(event) {
97	this.menu.toggle();	95	this.menu.toggle();
98	},	96	},
99
100	_onLaunchSettings: function() {
101	this.menu.close();
102	Util.spawnCommandLine("cinnamon-settings calendar");
103	},
104		97
105	_updateClockAndDate: function() {	98	_updateClockAndDate: function() {
106	let dateFormat = this._calendarSettings.get_string('date-format');	99	let dateFormat = this._calendarSettings.get_string('date-format');

Lines 11-19 try: Link Here

(-)a/files/usr/lib/cinnamon-settings/cinnamon-settings.py (-263 / +2 lines)
11	import gconf	11	import gconf
12	import json	12	import json
13	import dbus	13	import dbus
14	import tz
15	import time
16	from datetime import datetime
17	from user import home	14	from user import home
18	import thread	15	import thread
19	except Exception, detail:	16	except Exception, detail:
Lines 738-982 class GSettingsComboBox(Gtk.HBox): Link Here
738	value = self.model[tree_iter][0]	735	value = self.model[tree_iter][0]
739	self.settings.set_string(self.key, value)	736	self.settings.set_string(self.key, value)
740		737
741	class TimeZoneSelectorWidget(Gtk.HBox):
742	def __init__(self):
743	super(TimeZoneSelectorWidget, self).__init__()
744
745	proxy = dbus.SystemBus().get_object("org.gnome.SettingsDaemon.DateTimeMechanism", "/")
746	self.dbus_iface = dbus.Interface(proxy, dbus_interface="org.gnome.SettingsDaemon.DateTimeMechanism")
747
748	self.timezones = tz.load_db()
749
750	self.selected_region, self.selected_city = self.get_selected_zone()
751
752	region_label = Gtk.Label(_("Region"))
753	self.pack_start(region_label, False, False, 2)
754
755	regions = self.timezones.keys()
756	regions.sort()
757	self.region_model = Gtk.ListStore(str, str)
758	selected_region_iter = None
759	for region in regions:
760	iter = self.region_model.insert_before(None, None)
761	self.region_model.set_value(iter, 0, region)
762	self.region_model.set_value(iter, 1, region.replace("_", " "))
763	if (region == self.selected_region):
764	selected_region_iter = iter
765
766	self.region_widget = Gtk.ComboBox.new_with_model(self.region_model)
767	renderer_text = Gtk.CellRendererText()
768	self.region_widget.pack_start(renderer_text, True)
769	self.region_widget.add_attribute(renderer_text, "text", 1)
770	if selected_region_iter is not None:
771	self.region_widget.set_active_iter(selected_region_iter)
772	self.pack_start(self.region_widget, False, False, 2)
773
774	city_label = Gtk.Label(_("City"))
775	self.pack_start(city_label, False, False, 2)
776
777	self.city_model = Gtk.ListStore(str, str)
778	self.city_widget = Gtk.ComboBox.new_with_model(self.city_model)
779	renderer_text = Gtk.CellRendererText()
780	self.city_widget.pack_start(renderer_text, True)
781	self.city_widget.add_attribute(renderer_text, "text", 1)
782	self.pack_start(self.city_widget, False, False, 2)
783
784	self.update_cities_list()
785
786	self.region_widget.connect("changed", self.on_region_changed)
787	self.city_widget.connect("changed", self.on_city_changed)
788	def on_city_changed(self, widget):
789	tree_iter = widget.get_active_iter()
790	if tree_iter != None:
791	self.selected_city = self.city_model[tree_iter][0]
792	self.dbus_iface.SetTimezone(self.selected_region+"/"+self.selected_city)
793	def on_region_changed(self, widget):
794	tree_iter = widget.get_active_iter()
795	if tree_iter != None:
796	self.selected_region = self.region_model[tree_iter][0]
797	self.update_cities_list()
798	def update_cities_list(self):
799	self.city_model.clear()
800	if self.selected_region and self.selected_region in self.timezones.keys():
801	cities = self.timezones[self.selected_region]
802	cities.sort()
803	selected_city_iter = None
804	for city in cities:
805	iter = self.city_model.insert_before(None, None)
806	self.city_model.set_value(iter, 0, city)
807	self.city_model.set_value(iter, 1, city.replace("_", " "))
808	if (city == self.selected_city):
809	selected_city_iter = iter
810	if selected_city_iter is not None:
811	self.city_widget.set_active_iter(selected_city_iter)
812	def get_selected_zone(self):
813	tz = self.dbus_iface.GetTimezone()
814	if "/" in tz:
815	i = tz.index("/")
816	region = tz[:i]
817	city = tz[i+1:]
818	return region, city
819	else:
820	return "", ""
821
822	class ChangeTimeWidget(Gtk.HBox):
823	def __init__(self):
824	super(ChangeTimeWidget, self).__init__()
825	proxy = dbus.SystemBus().get_object("org.gnome.SettingsDaemon.DateTimeMechanism", "/")
826	self.dbus_iface = dbus.Interface(proxy, dbus_interface="org.gnome.SettingsDaemon.DateTimeMechanism")
827
828	# Ensures we are setting the system time only when the user changes it
829	self.changedOnTimeout = False
830
831	# Ensures we do not update the values in the date/time fields during the DBus call to set the time
832	self._setting_time = False
833	self._setting_time_lock = thread.allocate()
834	self._time_to_set = None
835
836	self.thirtyDays = [3, 5, 8, 10]
837	months = ['January','February','March','April','May','June','July','August','September','October','November','December']
838
839	# Boxes
840	timeBox = Gtk.HBox()
841	dateBox = Gtk.HBox()
842
843	# Combo Boxes
844	self.monthBox = Gtk.ComboBoxText()
845
846	for month in months:
847	self.monthBox.append_text(month)
848
849	# Adjustments
850	hourAdj = Gtk.Adjustment(0, 0, 23, 1, 1)
851	minAdj = Gtk.Adjustment(0, 0, 59, 1, 1)
852	yearAdj = Gtk.Adjustment(0, 0, 9999, 1, 5)
853	dayAdj = Gtk.Adjustment(0, 1, 31, 1, 1)
854
855	# Spin buttons
856	self.hourSpin = Gtk.SpinButton()
857	self.minSpin = Gtk.SpinButton()
858	self.yearSpin = Gtk.SpinButton()
859	self.daySpin = Gtk.SpinButton()
860
861	self.hourSpin.configure(hourAdj, 0.5, 0)
862	self.minSpin.configure(minAdj, 0.5, 0)
863	self.yearSpin.configure(yearAdj, 0.5, 0)
864	self.daySpin.configure(dayAdj, 0.5, 0)
865	#self.hourSpin.set_editable(False)
866	#self.minSpin.set_editable(False)
867	#self.yearSpin.set_editable(False)
868	#self.daySpin.set_editable(False)
869
870	self.update_time()
871	GObject.timeout_add(1000, self.update_time)
872
873	# Connect to callback
874	self.hourSpin.connect('changed', self._change_system_time)
875	self.minSpin.connect('changed', self._change_system_time)
876	self.monthBox.connect('changed', self._change_system_time)
877	self.yearSpin.connect('changed', self._change_system_time)
878	self.daySpin.connect('changed', self._change_system_time)
879
880	timeBox.pack_start(self.hourSpin, False, False, 2)
881	timeBox.pack_start(Gtk.Label(_(":")), False, False, 2)
882	timeBox.pack_start(self.minSpin, False, False, 2)
883
884	dateBox.pack_start(self.monthBox, False, False, 2)
885	dateBox.pack_start(self.daySpin, False, False, 2)
886	dateBox.pack_start(self.yearSpin, False, False, 2)
887
888	self.pack_start(Gtk.Label(_("Date : ")), False, False, 2)
889	self.pack_start(dateBox, True, True, 2)
890	self.pack_start(Gtk.Label(_("Time : ")), False, False, 2)
891	self.pack_start(timeBox, True, True, 2)
892
893	def update_time(self):
894	self._setting_time_lock.acquire()
895	do_update = not self._setting_time
896	self._setting_time_lock.release()
897
898	if not do_update:
899	return True
900
901	dt = datetime.now()
902
903	self.changedOnTimeout = True
904
905	# Time
906	self.hourSpin.set_value( dt.hour )
907	self.minSpin.set_value( dt.minute )
908
909	# Date
910	self.monthBox.set_active( dt.month-1 )
911	self.daySpin.set_value( dt.day )
912	self.yearSpin.set_value( dt.year )
913
914	self.changedOnTimeout = False
915
916	# Update the max of the day spin box
917	maxDay = 31
918	if dt.month == 2:
919	if dt.year % 4 == 0:
920	maxDay = 29
921	else:
922	maxDay = 28
923	elif dt.month-1 in self.thirtyDays:
924	maxDay = 30
925
926	self.daySpin.get_adjustment().set_upper(maxDay)
927
928	return True
929
930	def change_using_ntp(self, usingNtp):
931	# Check if we were using Ntp by seeing if the spin button
932	# is sensitive
933	self.set_sensitive(not usingNtp)
934
935	def _do_change_system_time(self):
936	self._setting_time_lock.acquire()
937	do_set = not self._setting_time
938	self._setting_time = True
939	self._setting_time_lock.release()
940
941	# If there is already another thread updating the time, we let it do the job
942	if not do_set:
943	return
944
945	done = False
946	while not done:
947	self._setting_time_lock.acquire()
948	time_to_set = self._time_to_set
949	self._time_to_set = None
950	self._setting_time_lock.release()
951
952	self.dbus_iface.SetTime(time_to_set)
953
954	# Check whether another request to set the time was done since this thread started
955	self._setting_time_lock.acquire()
956	if self._time_to_set==None:
957	done = True
958	self._setting_time_lock.release()
959
960	self._setting_time_lock.acquire()
961	self._setting_time = False
962	self._setting_time_lock.release()
963
964	def _change_system_time(self, widget):
965	if not self.changedOnTimeout:
966	hour = int( self.hourSpin.get_value() )
967	minute = int( self.minSpin.get_value() )
968	month = self.monthBox.get_active() + 1
969	day = int( self.daySpin.get_value() )
970	year = int( self.yearSpin.get_value() )
971
972	newDt = datetime(year, month, day, hour, minute)
973
974	self._setting_time_lock.acquire()
975	self._time_to_set = time.mktime(newDt.utctimetuple())
976	self._setting_time_lock.release()
977
978	thread.start_new_thread(self._do_change_system_time, ())
979
980	class TitleBarButtonsOrderSelector(Gtk.Table):	738	class TitleBarButtonsOrderSelector(Gtk.Table):
981	def __init__(self):	739	def __init__(self):
982	self.key = "/desktop/cinnamon/windows/button_layout"	740	self.key = "/desktop/cinnamon/windows/button_layout"
Lines 1121-1147 class MainWindow: Link Here
1121	sidePage.add_widget(GSettingsCheckButton(_("Panel Launchers draggable"), "org.cinnamon", "panel-launchers-draggable"))	879	sidePage.add_widget(GSettingsCheckButton(_("Panel Launchers draggable"), "org.cinnamon", "panel-launchers-draggable"))
1122		880
1123	sidePage = SidePage(_("Calendar"), "clock.svg", self.content_box)	881	sidePage = SidePage(_("Calendar"), "clock.svg", self.content_box)
1124	self.sidePages.append((sidePage, "calendar"))	882	self.sidePages.append((sidePage, "calendar"))
1125	self.changeTimeWidget = ChangeTimeWidget()
1126	sidePage.add_widget(GSettingsCheckButton(_("Show week dates in calendar"), "org.cinnamon.calendar", "show-weekdate"))	883	sidePage.add_widget(GSettingsCheckButton(_("Show week dates in calendar"), "org.cinnamon.calendar", "show-weekdate"))
1127	sidePage.add_widget(GSettingsEntry(_("Date format for the panel"), "org.cinnamon.calendar", "date-format"))	884	sidePage.add_widget(GSettingsEntry(_("Date format for the panel"), "org.cinnamon.calendar", "date-format"))
1128	sidePage.add_widget(GSettingsEntry(_("Date format inside the date applet"), "org.cinnamon.calendar", "date-format-full"))	885	sidePage.add_widget(GSettingsEntry(_("Date format inside the date applet"), "org.cinnamon.calendar", "date-format-full"))
1129	sidePage.add_widget(Gtk.LinkButton.new_with_label("http://www.foragoodstrftime.com/", _("Generate your own date formats")))	886	sidePage.add_widget(Gtk.LinkButton.new_with_label("http://www.foragoodstrftime.com/", _("Generate your own date formats")))
1130	self.ntpCheckButton = None	887
1131	try:
1132	self.ntpCheckButton = DBusCheckButton(_("Use network time"), "org.gnome.SettingsDaemon.DateTimeMechanism", "/", "GetUsingNtp", "SetUsingNtp")
1133	sidePage.add_widget(self.ntpCheckButton)
1134	except:
1135	pass
1136	sidePage.add_widget(self.changeTimeWidget)
1137	try:
1138	sidePage.add_widget(TimeZoneSelectorWidget())
1139	except:
1140	pass
1141
1142	if self.ntpCheckButton != None:
1143	self.ntpCheckButton.connect('toggled', self._ntp_toggled)
1144	self.changeTimeWidget.change_using_ntp( self.ntpCheckButton.get_active() )
1145		888
1146	sidePage = SidePage(_("Hot corner"), "overview.svg", self.content_box)	889	sidePage = SidePage(_("Hot corner"), "overview.svg", self.content_box)
1147	self.sidePages.append((sidePage, "hotcorner"))	890	self.sidePages.append((sidePage, "hotcorner"))
Lines 1316-1322 class MainWindow: Link Here
1316	sidePage.add_widget(GSettingsFontButton(_("Default font"), "org.gnome.desktop.interface", "font-name"))	1059	sidePage.add_widget(GSettingsFontButton(_("Default font"), "org.gnome.desktop.interface", "font-name"))
1317	sidePage.add_widget(GSettingsFontButton(_("Document font"), "org.gnome.desktop.interface", "document-font-name"))	1060	sidePage.add_widget(GSettingsFontButton(_("Document font"), "org.gnome.desktop.interface", "document-font-name"))
1318	sidePage.add_widget(GSettingsFontButton(_("Monospace font"), "org.gnome.desktop.interface", "monospace-font-name"))	1061	sidePage.add_widget(GSettingsFontButton(_("Monospace font"), "org.gnome.desktop.interface", "monospace-font-name"))
1319	sidePage.add_widget(GConfFontButton(_("Window title font"), "/apps/metacity/general/titlebar_font"))
1320	sidePage.add_widget(GSettingsComboBox(_("Hinting"), "org.gnome.settings-daemon.plugins.xsettings", "hinting", [(i, i.title()) for i in ("none", "slight", "medium", "full")]))	1062	sidePage.add_widget(GSettingsComboBox(_("Hinting"), "org.gnome.settings-daemon.plugins.xsettings", "hinting", [(i, i.title()) for i in ("none", "slight", "medium", "full")]))
1321	sidePage.add_widget(GSettingsComboBox(_("Antialiasing"), "org.gnome.settings-daemon.plugins.xsettings", "antialiasing", [(i, i.title()) for i in ("none", "grayscale", "rgba")]))	1063	sidePage.add_widget(GSettingsComboBox(_("Antialiasing"), "org.gnome.settings-daemon.plugins.xsettings", "antialiasing", [(i, i.title()) for i in ("none", "grayscale", "rgba")]))
1322		1064
Lines 1357-1365 class MainWindow: Link Here
1357	self.content_box_sw.hide()	1099	self.content_box_sw.hide()
1358	self.top_button_box.hide()	1100	self.top_button_box.hide()
1359	self.side_view_sw.show_all()	1101	self.side_view_sw.show_all()
1360
1361	def _ntp_toggled(self, widget):
1362	self.changeTimeWidget.change_using_ntp( self.ntpCheckButton.get_active() )
1363		1102
1364		1103
1365	if __name__ == "__main__":	1104	if __name__ == "__main__":

Lines 1-35 Link Here

(-)a/files/usr/lib/cinnamon-settings/tz.py (-35 lines)
1	import os
2
3	def load_db():
4	tz_db = {}
5
6	filename = '/usr/share/zoneinfo/zone.tab'
7	if not os.path.exists(filename):
8	filename = '/usr/share/lib/zoneinfo/tab/zone_sun.tab'
9	if not os.path.exists(filename):
10	return {}
11
12	tz_file = open(filename)
13
14	for line in tz_file:
15	line = line.rstrip().lstrip()
16	if line=="" or line[0] == '#':
17	continue
18
19	tz_info = line.split('\t')
20	if len(tz_info)<3:
21	continue
22	tz = tz_info[2]
23	if "/" in tz:
24	i = tz.index("/")
25	region = tz[:i]
26	zone = tz[i+1:]
27
28	if region not in tz_db:
29	tz_db[region] = []
30
31	tz_db[region].append(zone)
32
33	tz_file.close()
34
35	return tz_db