source: ubiquity/trunk/fuentes/ubiquity/plugins/ubi-timezone.py @ 1053

Last change on this file since 1053 was 1053, checked in by kbut, 4 years ago

add ubiquity

File size: 28.3 KB
Line 
1# -*- coding: utf-8; Mode: Python; indent-tabs-mode: nil; tab-width: 4 -*-
2
3# Copyright (C) 2006, 2007, 2008 Canonical Ltd.
4# Written by Colin Watson <cjwatson@ubuntu.com>.
5#
6# This program is free software; you can redistribute it and/or modify
7# it under the terms of the GNU General Public License as published by
8# the Free Software Foundation; either version 2 of the License, or
9# (at your option) any later version.
10#
11# This program is distributed in the hope that it will be useful,
12# but WITHOUT ANY WARRANTY; without even the implied warranty of
13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14# GNU General Public License for more details.
15#
16# You should have received a copy of the GNU General Public License
17# along with this program; if not, write to the Free Software
18# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
20from __future__ import print_function
21
22import os
23import re
24import time
25from urllib.parse import quote
26
27import debconf
28import icu
29
30from ubiquity import i18n, misc, plugin
31import ubiquity.tz
32
33
34NAME = 'timezone'
35# after partman for default install, but language for oem install
36AFTER = ['partman', 'language']
37WEIGHT = 10
38
39_geoname_url = 'http://geoname-lookup.ubuntu.com/?query=%s&release=%s'
40
41
42class PageGtk(plugin.PluginUI):
43    plugin_title = 'ubiquity/text/timezone_heading_label'
44
45    def __init__(self, controller, *args, **kwargs):
46        self.controller = controller
47        from gi.repository import Gtk
48        builder = Gtk.Builder()
49        self.controller.add_builder(builder)
50        builder.add_from_file(os.path.join(
51            os.environ['UBIQUITY_GLADE'], 'stepLocation.ui'))
52        builder.connect_signals(self)
53        self.page = builder.get_object('stepLocation')
54        self.city_entry = builder.get_object('timezone_city_entry')
55        self.map_window = builder.get_object('timezone_map_window')
56        self.setup_page()
57        self.timezone = None
58        self.zones = []
59        self.plugin_widgets = self.page
60        self.geoname_cache = {}
61        self.geoname_session = None
62        self.geoname_timeout_id = None
63        self.online = False
64
65    def plugin_set_online_state(self, state):
66        self.online = state
67
68    def plugin_translate(self, lang):
69        # c = self.controller
70        # if c.get_string('ubiquity/imported/time-format', lang) == '12-hour':
71        #    fmt = c.get_string('ubiquity/imported/12-hour', lang)
72        # else:
73        #    fmt = c.get_string('ubiquity/imported/24-hour', lang)
74        # self.tzmap.set_time_format(fmt)
75        inactive = self.controller.get_string(
76            'timezone_city_entry_inactive_label', lang)
77        self.city_entry.set_placeholder_text(inactive)
78
79    def set_timezone(self, timezone):
80        self.zones = self.controller.dbfilter.build_timezone_list()
81        self.tzmap.set_timezone(timezone)
82
83    def get_timezone(self):
84        return self.timezone
85
86    def select_city(self, unused_widget, city):
87        city = city.get_property('zone')
88        loc = self.tzdb.get_loc(city)
89        if not loc:
90            self.controller.allow_go_forward(False)
91        else:
92            self.city_entry.set_text(loc.human_zone)
93            self.city_entry.set_position(-1)
94            self.timezone = city
95            self.controller.allow_go_forward(True)
96
97    def changed(self, entry):
98        from gi.repository import Gtk, GObject, GLib, Soup
99
100        text = misc.utf8(self.city_entry.get_text())
101        if not text:
102            return
103        # TODO if the completion widget has a selection, return?  How do we
104        # determine this?
105        if text in self.geoname_cache:
106            model = self.geoname_cache[text]
107            self.city_entry.get_completion().set_model(model)
108        else:
109            model = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING,
110                                  GObject.TYPE_STRING, GObject.TYPE_STRING,
111                                  GObject.TYPE_STRING)
112
113            if self.geoname_session is None:
114                self.geoname_session = Soup.SessionAsync()
115            url = _geoname_url % (quote(text), misc.get_release().version)
116            message = Soup.Message.new('GET', url)
117            message.request_headers.append('User-agent', 'Ubiquity/1.0')
118            self.geoname_session.abort()
119            if self.geoname_timeout_id is not None:
120                GLib.source_remove(self.geoname_timeout_id)
121            self.geoname_timeout_id = \
122                GLib.timeout_add_seconds(2, self.geoname_timeout,
123                                         (text, model))
124            self.geoname_session.queue_message(message, self.geoname_cb,
125                                               (text, model))
126
127    def geoname_add_tzdb(self, text, model):
128        if len(model):
129            # already added
130            return
131
132        # TODO benchmark this
133        results = [
134            (name, self.tzdb.get_loc(city))
135            for name, city in [
136                (x[0], x[1])
137                for x in self.zones
138                if x[0].lower().split('(', 1)[-1].startswith(text.lower())]]
139        for result in results:
140            # We use name rather than loc.human_zone for i18n.
141            # TODO this looks pretty awful for US results:
142            # United States (New York) (United States)
143            # Might want to match the debconf format.
144            name, loc = result
145            model.append([name, '', loc.human_country,
146                          str(loc.latitude), str(loc.longitude)])
147
148    def geoname_timeout(self, user_data):
149        text, model = user_data
150        self.geoname_add_tzdb(text, model)
151        self.geoname_timeout_id = None
152        self.city_entry.get_completion().set_model(model)
153        return False
154
155    def geoname_cb(self, session, message, user_data):
156        import syslog
157        import json
158        from gi.repository import GLib, Soup
159
160        text, model = user_data
161
162        if self.geoname_timeout_id is not None:
163            GLib.source_remove(self.geoname_timeout_id)
164            self.geoname_timeout_id = None
165        self.geoname_add_tzdb(text, model)
166
167        if message.status_code == Soup.KnownStatusCode.CANCELLED:
168            # Silently ignore cancellation.
169            pass
170        elif message.status_code != Soup.KnownStatusCode.OK:
171            # Log but otherwise ignore failures.
172            syslog.syslog(
173                'Geoname lookup for "%s" failed: %d %s' %
174                (text, message.status_code, message.reason_phrase))
175        else:
176            try:
177                for result in json.loads(message.response_body.data):
178                    model.append([
179                        result['name'], result['admin1'], result['country'],
180                        result['latitude'], result['longitude']])
181
182                # Only cache positive results.
183                self.geoname_cache[text] = model
184
185            except ValueError:
186                syslog.syslog(
187                    'Server return does not appear to be valid JSON.')
188
189        self.city_entry.get_completion().set_model(model)
190
191    def setup_page(self):
192        # TODO Put a frame around the completion to add contrast (LP: # 605908)
193        from gi.repository import Gtk, GLib
194        from gi.repository import TimezoneMap
195        self.tzdb = ubiquity.tz.Database()
196        self.tzmap = TimezoneMap.TimezoneMap()
197        self.tzmap.connect('location-changed', self.select_city)
198        self.map_window.add(self.tzmap)
199        self.tzmap.show()
200
201        def is_separator(m, i):
202            return m[i][0] is None
203
204        self.timeout_id = 0
205
206        def queue_entry_changed(entry):
207            if self.timeout_id:
208                GLib.source_remove(self.timeout_id)
209            self.timeout_id = GLib.timeout_add(300, self.changed, entry)
210
211        self.city_entry.connect('changed', queue_entry_changed)
212        completion = Gtk.EntryCompletion()
213        self.city_entry.set_completion(completion)
214        completion.set_inline_completion(True)
215        completion.set_inline_selection(True)
216
217        def match_selected(completion, model, iterator):
218            # Select on map.
219            lat = float(model[iterator][3])
220            lon = float(model[iterator][4])
221            self.tzmap.set_coords(lon, lat)
222
223            self.city_entry.set_text(model[iterator][0])
224            self.city_entry.set_position(-1)
225            return True
226        completion.connect('match-selected', match_selected)
227
228        def match_func(completion, key, iterator, data):
229            # We've already determined that it's a match in entry_changed.
230            return True
231
232        def data_func(column, cell, model, iterator, data):
233            row = model[iterator]
234            if row[1]:
235                # The result came from geonames, and thus has an administrative
236                # zone attached to it.
237                text = '%s <small>(%s, %s)</small>' % (row[0], row[1], row[2])
238            else:
239                text = '%s <small>(%s)</small>' % (row[0], row[2])
240            cell.set_property('markup', text)
241        cell = Gtk.CellRendererText()
242        completion.pack_start(cell, True)
243        completion.set_match_func(match_func, None)
244        completion.set_cell_data_func(cell, data_func, None)
245
246
247class PageKde(plugin.PluginUI):
248    plugin_breadcrumb = 'ubiquity/text/breadcrumb_timezone'
249
250    def __init__(self, controller, *args, **kwargs):
251        self.controller = controller
252        try:
253            from PyQt4 import uic
254            from ubiquity.frontend.kde_components.Timezone import TimezoneMap
255
256            self.page = uic.loadUi('/usr/share/ubiquity/qt/stepLocation.ui')
257            self.tzmap = TimezoneMap(self.page.map_frame)
258            self.page.map_frame.layout().addWidget(self.tzmap)
259
260            self.tzmap.zoneChanged.connect(self.mapZoneChanged)
261            self.page.timezone_zone_combo.currentIndexChanged[int].connect(
262                self.regionChanged)
263            self.page.timezone_city_combo.currentIndexChanged[int].connect(
264                self.cityChanged)
265        except Exception as e:
266            self.debug('Could not create timezone page: %s', e)
267            self.page = None
268
269        self.plugin_widgets = self.page
270        self.online = False
271
272    def plugin_set_online_state(self, state):
273        self.online = state
274
275    @plugin.only_this_page
276    def refresh_timezones(self):
277        lang = os.environ['LANG'].split('_', 1)[0]
278        shortlist = self.controller.dbfilter.build_shortlist_region_pairs(lang)
279        longlist = self.controller.dbfilter.build_region_pairs()
280
281        self.page.timezone_zone_combo.clear()
282        for pair in shortlist:
283            self.page.timezone_zone_combo.addItem(pair[0], pair[1])
284        self.page.timezone_zone_combo.insertSeparator(
285            self.page.timezone_zone_combo.count())
286        for pair in longlist:
287            self.page.timezone_zone_combo.addItem(pair[0], pair[2])
288
289    @plugin.only_this_page
290    def populateCities(self, regionIndex):
291        self.page.timezone_city_combo.clear()
292
293        code = str(
294            self.page.timezone_zone_combo.itemData(regionIndex).toPyObject())
295        countries = self.controller.dbfilter.get_countries_for_region(code)
296        if not countries:  # must have been a country code itself
297            countries = [code]
298
299        shortlist, longlist = self.controller.dbfilter.build_timezone_pairs(
300            countries)
301
302        for pair in shortlist:
303            self.page.timezone_city_combo.addItem(pair[0], pair[1])
304        if shortlist:
305            self.page.timezone_city_combo.insertSeparator(
306                self.page.timezone_city_combo.count())
307        for pair in longlist:
308            self.page.timezone_city_combo.addItem(pair[0], pair[1])
309
310        return (len(countries) == 1 and
311                self.controller.dbfilter.get_default_for_region(countries[0]))
312
313    # called when the region(zone) combo changes
314    @plugin.only_this_page
315    def regionChanged(self, regionIndex):
316        if self.controller.dbfilter is None:
317            return
318
319        self.page.timezone_city_combo.blockSignals(True)
320        # self.page.timezone_city_combo.currentIndexChanged[int].disconnect(
321        #    self.cityChanged)
322        default = self.populateCities(regionIndex)
323        self.page.timezone_city_combo.blockSignals(False)
324        # self.page.timezone_city_combo.currentIndexChanged[int].connect(
325        #    self.cityChanged)
326
327        if default:
328            self.tzmap.set_timezone(default)
329        else:
330            self.cityChanged(0)
331
332    # called when the city combo changes
333    def cityChanged(self, cityindex):
334        zone = str(
335            self.page.timezone_city_combo.itemData(cityindex).toPyObject())
336        self.tzmap.zoneChanged.disconnect(self.mapZoneChanged)
337        self.tzmap.set_timezone(zone)
338        self.tzmap.zoneChanged.connect(self.mapZoneChanged)
339
340    @plugin.only_this_page
341    def mapZoneChanged(self, loc, zone):
342        self.page.timezone_zone_combo.blockSignals(True)
343        self.page.timezone_city_combo.blockSignals(True)
344
345        for i in range(self.page.timezone_zone_combo.count()):
346            code = str(self.page.timezone_zone_combo.itemData(i).toPyObject())
347            countries = self.controller.dbfilter.get_countries_for_region(code)
348            if not countries:  # must have been a country code itself
349                countries = [code]
350            if loc.country in countries:
351                self.page.timezone_zone_combo.setCurrentIndex(i)
352                self.populateCities(i)
353                break
354
355        for i in range(self.page.timezone_city_combo.count()):
356            code = str(self.page.timezone_city_combo.itemData(i).toPyObject())
357            if zone == code:
358                self.page.timezone_city_combo.setCurrentIndex(i)
359                self.cityChanged(i)
360                break
361
362        self.page.timezone_zone_combo.blockSignals(False)
363        self.page.timezone_city_combo.blockSignals(False)
364
365    def set_timezone(self, timezone):
366        self.refresh_timezones()
367        self.tzmap.set_timezone(timezone)
368
369    def get_timezone(self):
370        return self.tzmap.get_timezone()
371
372
373class PageDebconf(plugin.PluginUI):
374    plugin_title = 'ubiquity/text/timezone_heading_label'
375
376    def __init__(self, controller, *args, **kwargs):
377        self.controller = controller
378        self.online = False
379
380    def plugin_set_online_state(self, state):
381        self.online = state
382
383
384class PageNoninteractive(plugin.PluginUI):
385    def __init__(self, controller, *args, **kwargs):
386        self.controller = controller
387        self.online = False
388
389    def plugin_set_online_state(self, state):
390        self.online = state
391
392    def set_timezone(self, timezone):
393        """Set the current selected timezone."""
394        self.timezone = timezone
395
396    def get_timezone(self):
397        """Get the current selected timezone."""
398        return self.timezone
399
400
401class Page(plugin.Plugin):
402    def prepare(self, unfiltered=False):
403        # TODO: This can go away once we have the ability to abort wget/rdate
404        if not self.ui.online:
405            self.preseed('tzsetup/geoip_server', '')
406            self.preseed('clock-setup/ntp', 'false')
407
408        clock_script = '/usr/share/ubiquity/clock-setup'
409        env = {'PATH': '/usr/share/ubiquity:' + os.environ['PATH']}
410
411        # TODO: replace with more general version pushed down into
412        # is_automatic or similar
413        try:
414            self.automatic_page = (
415                self.db.get("ubiquity/automatic/timezone") == "true")
416        except debconf.DebconfError:
417            self.automatic_page = False
418
419        if unfiltered:
420            # In unfiltered mode, localechooser is responsible for selecting
421            # the country, so there's no need to repeat the job here.
422            env['TZSETUP_NO_LOCALECHOOSER'] = '1'
423            return ([clock_script], ['CAPB', 'PROGRESS'], env)
424
425        self.timezones = []
426        self.regions = {}
427        self.tzdb = ubiquity.tz.Database()
428        self.multiple = False
429        try:
430            # Strip .UTF-8 from locale, icu doesn't parse it
431            locale = os.environ['LANG'].rsplit('.', 1)[0]
432            self.collator = icu.Collator.createInstance(icu.Locale(locale))
433        except:
434            self.collator = None
435        if self.is_automatic or self.automatic_page:
436            if self.db.fget('time/zone', 'seen') == 'true':
437                self.set_di_country(self.db.get('time/zone'))
438        else:
439            self.db.fset('time/zone', 'seen', 'false')
440            cc = self.db.get('debian-installer/country')
441            try:
442                self.db.get('tzsetup/country/%s' % cc)
443                # ... and if that succeeded:
444                self.multiple = True
445            except debconf.DebconfError:
446                pass
447        self.preseed('tzsetup/selected', 'false')
448        questions = ['^time/zone$', '^tzsetup/detected$', 'CAPB', 'PROGRESS']
449        return [clock_script], questions, env
450
451    def capb(self, capabilities):
452        self.frontend.debconf_progress_cancellable(
453            'progresscancel' in capabilities)
454
455    def run(self, priority, question):
456        if question == 'tzsetup/detected':
457            zone = self.db.get('time/zone')
458            self.ui.set_timezone(zone)
459        elif question == 'time/zone':
460            if self.multiple:
461                # Work around a debconf bug: REGISTER does not appear to
462                # give a newly-registered question the same default as the
463                # question associated with its template, unless we also
464                # RESET it.
465                self.db.reset(question)
466            zone = self.db.get(question)
467            # Some countries don't have a default zone, so just pick the
468            # first choice in the list.
469            if not zone:
470                choices_c = self.choices_untranslated(question)
471                if choices_c:
472                    zone = choices_c[0]
473            self.ui.set_timezone(zone)
474
475        if self.automatic_page:
476            # TODO: invade frontend's privacy to avoid entering infinite
477            # loop when trying to back up over timezone question (which
478            # isn't possible anyway since it's just after partitioning);
479            # this needs to be tidied up substantially when generalising
480            # ubiquity/automatic/*
481            self.frontend.backup = False
482            return True
483        else:
484            return plugin.Plugin.run(self, priority, question)
485
486    def get_default_for_region(self, region):
487        try:
488            return self.db.get('tzsetup/country/%s' % region)
489        except debconf.DebconfError:
490            return None
491
492    def collation_key(self, s):
493        if self.collator:
494            try:
495                return self.collator.getCollationKey(s[0]).getByteArray()
496            except:
497                pass
498        return s[0]
499
500    def get_countries_for_region(self, region):
501        if region in self.regions:
502            return self.regions[region]
503
504        try:
505            codes = self.choices_untranslated(
506                'localechooser/countrylist/%s' % region)
507        except debconf.DebconfError:
508            codes = []
509        self.regions[region] = codes
510        return codes
511
512    # Returns ['timezone', ...]
513    def build_timezone_list(self):
514        total = []
515        continents = self.choices_untranslated('localechooser/continentlist')
516        for continent in continents:
517            country_codes = self.choices_untranslated(
518                'localechooser/countrylist/%s' % continent.replace(' ', '_'))
519            for c in country_codes:
520                shortlist = self.build_shortlist_timezone_pairs(c, sort=False)
521                longlist = self.build_longlist_timezone_pairs(c, sort=False)
522                shortcopy = shortlist[:]
523                # TODO set() | set() instead.
524                for short_item in shortcopy:
525                    for long_item in longlist:
526                        if short_item[1] == long_item[1]:
527                            shortlist.remove(short_item)
528                            break
529                total += shortlist + longlist
530        return total
531
532    # Returns [('translated country name', None, 'region code')...] list
533    def build_region_pairs(self):
534        continents = self.choices_display_map('localechooser/continentlist')
535        names, codes = list(zip(*continents.items()))
536        codes = [c.replace(' ', '_') for c in codes]
537
538        nones = [None for _ in continents]
539        pairs = list(zip(names, nones, codes))
540        pairs.sort(key=self.collation_key)
541        return pairs
542
543    # Returns [('translated short list of countries', 'timezone')...] list
544    def build_shortlist_region_pairs(self, language_code):
545        try:
546            shortlist = self.choices_display_map(
547                'localechooser/shortlist/%s' % language_code)
548            # Remove any 'other' entry
549            for pair in shortlist.items():
550                if pair[1] == 'other':
551                    del shortlist[pair[0]]
552                    break
553            names, codes = list(zip(*shortlist.items()))
554            nones = [None for _ in names]
555            shortlist = list(zip(names, codes, nones))
556            shortlist.sort(key=self.collation_key)
557            return shortlist
558        except debconf.DebconfError:
559            return []
560
561    # Returns (shortlist, longlist)
562    def build_timezone_pairs(self, country_codes):
563        if len(country_codes) == 1:
564            shortlist = self.build_shortlist_timezone_pairs(country_codes[0])
565        else:
566            shortlist = []
567
568        longlist = []
569        for country_code in country_codes:
570            longlist += self.build_longlist_timezone_pairs(
571                country_code, sort=False)
572        longlist.sort(key=self.collation_key)
573
574        # There may be duplicate entries in the shortlist and longlist.
575        # Basically, the shortlist is most useful when there are non-city
576        # timezones that may be more familiar to denizens of that country.
577        # Big examples are the US in which people tend to think in terms of
578        # Eastern/Mountain/etc.  If we see a match in tz code, prefer the
579        # longlist's translation and strip it from the shortlist.
580        # longlist tends to be more complete in terms of translation coverage
581        # (i.e. libicu is more translated than tzsetup)
582        shortcopy = shortlist[:]
583        for short_item in shortcopy:
584            for long_item in longlist:
585                if short_item[1] == long_item[1]:
586                    shortlist.remove(short_item)
587                    break
588
589        return (shortlist, longlist)
590
591    def build_shortlist_timezone_pairs(self, country_code, sort=True):
592        try:
593            shortlist = self.choices_display_map(
594                'tzsetup/country/%s' % country_code)
595            for pair in list(shortlist.items()):
596                # Remove any 'other' entry, we don't need it
597                if pair[1] == 'other':
598                    del shortlist[pair[0]]
599            shortlist = list(shortlist.items())
600            if sort:
601                shortlist.sort(key=self.collation_key)
602            return shortlist
603        except debconf.DebconfError:
604            return []
605
606    def get_country_name(self, country):
607        # Relatively expensive algorithmically, but we don't call this often.
608        try:
609            continents = self.choices_untranslated(
610                'localechooser/continentlist')
611            for continent in continents:
612                choices = self.choices_display_map(
613                    'localechooser/countrylist/%s' %
614                    continent.replace(' ', '_'))
615                for name, code in choices.items():
616                    if code == country:
617                        return name
618        except debconf.DebconfError as e:
619            print("Couldn't get country name for %s: %s" % (country, e))
620        return None
621
622    def get_city_name_from_tzdata(self, tz):
623        city = tz.split('/', 1)[1]
624        # Iterate through tzdata's regions, check each region's tz list for
625        # our city.  Like get_country_name, this is inefficient (we could
626        # cache this info), but we don't need to run this often.
627        try:
628            areas = self.choices_untranslated('tzdata/Areas')
629            for area in areas:
630                zones = self.choices_display_map('tzdata/Zones/%s' % area)
631                for name, code in zones.items():
632                    if code == city:
633                        return name
634        except debconf.DebconfError as e:
635            print("Couldn't get city name for %s: %s" % (tz, e))
636        return None
637
638    def get_fallback_translation_for_tz(self, country, tz):
639        # We want to return either 'Country' or 'Country (City)', translated
640        # First, get country name.  We need that regardless
641        country_name = self.get_country_name(country)
642        if country_name is None:
643            return None
644        show_city = len(self.tzdb.cc_to_locs[country]) > 1
645        if show_city:
646            # First, try tzdata's translation.
647            city_name = self.get_city_name_from_tzdata(tz)
648            if city_name is None:
649                city_name = tz  # fall back to ASCII name
650            city_name = city_name.split('/')[-1]
651            return "%s (%s)" % (country_name, city_name)
652        else:
653            return country_name
654
655    # Returns [('translated long list of timezones', 'timezone')...] list
656    def build_longlist_timezone_pairs(self, country_code, sort=True):
657        if 'LANG' not in os.environ:
658            return []  # ?!
659        locale = os.environ['LANG'].rsplit('.', 1)[0]
660        tz_format = icu.SimpleDateFormat('VVVV', icu.Locale(locale))
661        now = time.time() * 1000
662        rv = []
663        try:
664            locs = self.tzdb.cc_to_locs[country_code]  # BV failed?
665        except:
666            # Some countries in tzsetup don't exist in zone.tab...
667            # Specifically BV (Bouvet Island) and
668            # HM (Heard and McDonald Islands).  Both are uninhabited.
669            locs = []
670        for location in locs:
671            timezone = icu.TimeZone.createTimeZone(location.zone)
672            if timezone.getID() == 'Etc/Unknown':
673                translated = None
674            else:
675                tz_format.setTimeZone(timezone)
676                translated = tz_format.format(now)
677            # Check if icu had a valid translation for this timezone.  If it
678            # doesn't, the returned string will look like GMT+0002 or somesuch.
679            # Sometimes the GMT is translated (like in Chinese), so we check
680            # for the number part.  icu does not indicate a 'translation
681            # failure' like this in any way...
682            if (translated is None or
683                    re.search('.*[-+][0-9][0-9]:?[0-9][0-9]$', translated)):
684                # Wasn't something that icu understood...
685                name = self.get_fallback_translation_for_tz(
686                    country_code, location.zone)
687                rv.append((name, location.zone))
688            else:
689                rv.append((translated, location.zone))
690        if sort:
691            rv.sort(key=self.collation_key)
692        return rv
693
694    # Returns [('translated long list of timezones', 'timezone')...] list
695    def build_longlist_timezone_pairs_by_continent(self, continent):
696        if 'LANG' not in os.environ:
697            return []  # ?
698        rv = []
699        try:
700            regions = self.choices_untranslated(
701                'localechooser/countrylist/%s' % continent)
702            for region in regions:
703                rv += self.build_longlist_timezone_pairs(region, sort=False)
704            rv.sort(key=self.collation_key)
705        except debconf.DebconfError:
706            pass
707        return rv
708
709    def set_di_country(self, zone):
710        location = self.tzdb.get_loc(zone)
711        if location:
712            self.preseed('debian-installer/country', location.country)
713
714    def ok_handler(self):
715        zone = self.ui.get_timezone()
716        if zone is None:
717            zone = self.db.get('time/zone')
718        else:
719            self.preseed('time/zone', zone)
720        self.set_di_country(zone)
721        plugin.Plugin.ok_handler(self)
722
723    def cleanup(self):
724        plugin.Plugin.cleanup(self)
725        self.ui.controller.set_locale(i18n.reset_locale(self.frontend))
726
727
728class Install(plugin.InstallPlugin):
729    def prepare(self, unfiltered=False):
730        tzsetup_script = '/usr/lib/ubiquity/tzsetup/post-base-installer'
731        clock_script = '/usr/share/ubiquity/clock-setup-apply'
732
733        if 'UBIQUITY_OEM_USER_CONFIG' in os.environ:
734            tzsetup_script += '-oem'
735
736        return (['sh', '-c', '%s && %s' % (tzsetup_script, clock_script)], [])
737
738    def install(self, target, progress, *args, **kwargs):
739        progress.info('ubiquity/install/timezone')
740        return plugin.InstallPlugin.install(
741            self, target, progress, *args, **kwargs)
Note: See TracBrowser for help on using the repository browser.