chirpw

#!/usr/bin/env python
#
# Copyright 2014 Dan Smith <dsmith@danplanet.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty 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, see <http://www.gnu.org/licenses/>.

import os

from chirp import chirp_common
from chirp import logger
from chirp import elib_intl
from chirp import platform
from chirp.drivers import *
from chirp.ui import config


import sys
import os
import locale
import gettext
import argparse
import logging
import urllib

LOG = logging.getLogger("chirpw")


urllib.URLopener.version = chirp_common.http_user_agent()

localepath = platform.get_platform().find_resource("locale")

conf = config.get()
manual_language = conf.get("language", "state")
langs = []
if manual_language and manual_language != "Auto":
    lang_codes = {"English":              "en_US",
                  "Polish":               "pl",
                  "Italian":              "it",
                  "Dutch":                "nl",
                  "German":               "de",
                  "Hungarian":            "hu",
                  "Russian":              "ru",
                  "Portuguese (BR)":      "pt_BR",
                  "French":               "fr",
                  "Spanish":              "es_ES",
                  "Chinese (Simplified)": "zh_CN",
                  'Ukrainian':            "uk_UA",
                  }
    try:
        LOG.info("Language: %s", lang_codes[manual_language])
        langs = [lang_codes[manual_language]]
    except KeyError:
        LOG.error("Unsupported language `%s'" % manual_language)
else:
    lc, encoding = locale.getdefaultlocale()
    if (lc):
        langs = [lc]
    try:
        langs += os.getenv("LANG").split(":")
    except:
        pass

try:
    if os.name == "nt":
        elib_intl._putenv("LANG", langs[0])
    else:
        os.putenv("LANG", langs[0])
except IndexError:
    pass
path = "locale"
gettext.bindtextdomain("CHIRP", localepath)
gettext.textdomain("CHIRP")
lang = gettext.translation("CHIRP", localepath, languages=langs,
                           fallback=True)


# Python <2.6 does not have str.format(), which chirp uses to make translation
# strings nicer. So, instead of installing the gettext standard "_()" function,
# we can install our own, which returns a string of the following class,
# which emulates the new behavior, thus allowing us to run on older Python
# versions.
class CompatStr(str):
    def format(self, **kwargs):
        base = lang.gettext(self)
        for k, v in kwargs.items():
            base = base.replace("{%s}" % k, str(v))
        return base

pyver = sys.version.split()[0]

try:
    vmaj, vmin, vrel = pyver.split(".", 3)
except:
    vmaj, vmin = pyver.split(".", 2)
    vrel = 0

if int(vmaj) < 2 or int(vmin) < 6:
    # Python <2.6, emulate str.format()
    import __builtin__

    def lang_with_format(string):
        return CompatStr(string)
    __builtin__._ = lang_with_format
else:
    # Python >=2.6, use normal gettext behavior
    lang.install()

parser = argparse.ArgumentParser()
parser.add_argument("files", metavar="file", nargs='*', help="File to open")
parser.add_argument("--module", metavar="module",
                    help="Load module on startup")
logger.add_version_argument(parser)
parser.add_argument("--profile", action="store_true",
                    help="Enable profiling")
logger.add_arguments(parser)
args = parser.parse_args()

logger.handle_options(args)

a = None
if True:
    from chirp.ui import mainapp
    a = mainapp.ChirpMain()

# Be sure to load module before opening files
if args.module:
    a.load_module(args.module)

for i in args.files:
    LOG.info("Opening %s", i)
    a.do_open(i)

a.show()

if args.profile:
    import cProfile
    import pstats
    import gtk
    cProfile.run("gtk.main()", "chirpw.stats")
    p = pstats.Stats("chirpw.stats")
    p.sort_stats("cumulative").print_stats(10)
else:
    import gtk
    gtk.main()

if config._CONFIG:
    config._CONFIG.set("last_dir",
                       platform.get_platform().get_last_dir(),
                       "state")
    config._CONFIG.save()